11 files changed, 72 insertions, 20 deletions

diff --git a/noncore/apps/opie-console/BUGS b/noncore/apps/opie-console/BUGS
new file mode 100644
index 0000000..ffaceef
--- a/dev/null
+++ b/noncore/apps/opie-console/BUGS
@@ -0,0 +1,9 @@
+Ok we all know we write perfect code
+but sometimes the compiler produces bad code
+and we need to work around some compiler bugs!! -zecke
+
+MyPty is broken in some ways
+ if you do connect/disconnect/connect sh will be executed in the
+ process of opie-console.... funny aye?
+ 
+OTabWidget seems to give us problems too
diff --git a/noncore/apps/opie-console/MyPty.cpp b/noncore/apps/opie-console/MyPty.cpp
index b6ae1d9..565d03f 100644
--- a/noncore/apps/opie-console/MyPty.cpp
+++ b/noncore/apps/opie-console/MyPty.cpp
@@ -96,52 +96,55 @@
    actual size of the window.
 */
 
 void MyPty::setSize(int lines, int columns)
 {
   struct winsize wsize;
   wsize.ws_row = (unsigned short)lines;
   wsize.ws_col = (unsigned short)columns;
   if(m_fd < 0) return;
   ioctl(m_fd,TIOCSWINSZ,(char *)&wsize);
 }
 
 
 void MyPty::donePty()
 {
     // This is code from the Qt DumbTerminal example
     int status = 0;
 
     ::close(m_fd);
 
     if (m_cpid) {
 	kill(m_cpid, SIGHUP);
 	//waitpid(m_cpid, &status, 0);
         delete m_sn_e;
+        delete m_sn_r;
         m_sn_e = 0l;
+        m_sn_r = 0l;
     }
 
     m_cpid = 0;
+    m_fd = -1;
 //    emit done(status);
 }
 
 
 const char* MyPty::deviceName()
 {
     return m_ttynam;
 }
 
 
 void MyPty::error()
 {
     // This is code from the Qt DumbTerminal example
     donePty();
 }
 
 void MyPty::start() {
     char* cmd = "/bin/sh";
     QStrList lis;
     int r =run(cmd, lis, 0, 0);
     r = r;
 }
 /*!
     start the client program.
@@ -164,146 +167,158 @@ int MyPty::run(const char* cmd, QStrList &, const char*, int)
 	if ( setsid() < 0 )
 	    perror( "failed to set process group" );
 #if defined (TIOCSCTTY)
 	// grabbed from APUE by Stevens
 	ioctl(STDIN_FILENO, TIOCSCTTY, 0);
 #endif
 	tcgetattr( STDIN_FILENO, &ttmode );
 	ttmode.c_cc[VINTR] = 3;
 	ttmode.c_cc[VERASE] = 8;
 	tcsetattr( STDIN_FILENO, TCSANOW, &ttmode );
 	setenv("TERM","vt100",1);
 	setenv("COLORTERM","0",1);
 
 	if (getuid() == 0) {
 	    char msg[] = "WARNING: You are running this shell as root!\n";
 	    write(ttyfd, msg, sizeof(msg));
 	}
 	execl(cmd, cmd, 0);
 
 	donePty();
 	exit(-1);
     }
 
     // parent - continue as a widget
-    QSocketNotifier* sn_r = new QSocketNotifier(m_fd,QSocketNotifier::Read,this);
+    delete m_sn_r;
+    m_sn_r = new QSocketNotifier(m_fd,QSocketNotifier::Read,this);
     delete m_sn_e;
     m_sn_e = new QSocketNotifier(m_fd,QSocketNotifier::Exception,this);
-    connect(sn_r,SIGNAL(activated(int)),this,SLOT(readPty()));
+    connect(m_sn_r,SIGNAL(activated(int)),this,SLOT(readPty()));
     connect(m_sn_e,SIGNAL(activated(int)),this,SLOT(error()));
 
     return 0;
 }
 
 int MyPty::openPty()
 {
     // This is code from the Qt DumbTerminal example
     int ptyfd = -1;
 
 #ifdef HAVE_OPENPTY
     int ttyfd;
     if ( openpty(&ptyfd,&ttyfd,ttynam,0,0) )
 	ptyfd = -1;
     else
 	close(ttyfd); // we open the ttynam ourselves.
 #else
     for (const char* c0 = "pqrstuvwxyzabcde"; ptyfd < 0 && *c0 != 0; c0++) {
 	for (const char* c1 = "0123456789abcdef"; ptyfd < 0 && *c1 != 0; c1++) {
 	    sprintf(m_ptynam,"/dev/pty%c%c",*c0,*c1);
 	    sprintf(m_ttynam,"/dev/tty%c%c",*c0,*c1);
 	    if ((ptyfd = ::open(m_ptynam,O_RDWR)) >= 0) {
 		if (geteuid() != 0 && !access(m_ttynam,R_OK|W_OK) == 0) {
 		    ::close(ptyfd);
 		    ptyfd = -1;
 		}
 	    }
 	}
     }
 #endif
 
     if ( ptyfd < 0 ) {
-	qApp->exit(1);
+//	qApp->exit(1);
 	return -1;
     }
 
     return ptyfd;
 }
 
 /*!
     Create an instance.
 */
 MyPty::MyPty(const Profile&) : m_cpid(0)
 {
     m_sn_e = 0l;
+    m_sn_r = 0l;
   m_fd = openPty();
   ProcCtl* ctl = ProcCtl::self();
 }
 
 /*!
     Destructor.
     Note that the related client program is not killed
     (yet) when a instance is deleted.
 */
 MyPty::~MyPty()
 {
     donePty();
 }
 QString MyPty::identifier()const {
     return QString::fromLatin1("term");
 }
 QString MyPty::name()const{
     return identifier();
 }
 bool MyPty::open() {
+    if (m_fd < 0)
+        m_fd = openPty();
+
     start();
     return true;
 }
 void MyPty::close() {
     donePty();
+    m_fd = openPty();
 }
 void MyPty::reload( const Profile& ) {
 
 }
 /*! sends len bytes through the line */
 void MyPty::send(const QByteArray& ar)
 {
 #ifdef VERBOSE_DEBUG
   // verbose debug
   printf("sending bytes:\n");
   for (uint i = 0; i < ar.count(); i++)
     printf("%c", ar[i]);
   printf("\n");
 #endif
 
   ::write(m_fd, ar.data(), ar.count());
 }
 
 /*! indicates that a block of data is received */
 void MyPty::readPty()
 {
   QByteArray buf(4096);
 
   int len = ::read( m_fd, buf.data(), 4096 );
 
   if (len == -1 || len == 0) {
      donePty();
-     delete sender();
      return;
   }
 
   if (len < 0)
      return;
 
 
   buf.resize(len);
   emit received(buf);
 
 #ifdef VERBOSE_DEBUG
   // verbose debug
   printf("read bytes:\n");
   for (uint i = 0; i < buf.count(); i++)
     printf("%c", buf[i]);
   printf("\n");
 #endif
 
 }
+QBitArray MyPty::supports()const {
+    QBitArray ar(3);
+    ar[0] = 1;
+    ar[1] = 0;
+    ar[2] = 0;
 
+    return ar;
+}
diff --git a/noncore/apps/opie-console/MyPty.h b/noncore/apps/opie-console/MyPty.h
index 3166fa0..ad271df 100644
--- a/noncore/apps/opie-console/MyPty.h
+++ b/noncore/apps/opie-console/MyPty.h
@@ -20,48 +20,49 @@
 */
 
 #ifndef MY_PTY_H
 #define MY_PTY_H
 
 #include <qobject.h>
 #include <qstrlist.h>
 
 #include "io_layer.h"
 
 class Profile;
 class QSocketNotifier;
 class MyPty : public IOLayer
 {
     Q_OBJECT
 public:
 
     MyPty(const Profile&);
     ~MyPty();
 
 
 
     QString identifier()const;
     QString name()const;
+    QBitArray supports()const;
 
   public slots:
  /*!
       having a `run' separate from the constructor allows to make
       the necessary connections to the signals and slots of the
       instance before starting the execution of the client.
     */
     void start();
     int run(const char* pgm, QStrList & args , const char* term, int addutmp);
     bool open();
     void close();
     void reload( const Profile& );
     void setSize(int lines, int columns);
     void error();
 
   signals:
 
     /*!
         emitted when the client program terminates.
         \param status the wait(2) status code of the terminated client program.
     */
     void done(int status);
 
     /*!
@@ -71,27 +72,28 @@ public:
     */
     void received(const QByteArray&);
 
   public slots:
 
     void send(const QByteArray& );
 
 private:
     const char* deviceName();
 
 protected slots:
       void readPty();
       void donePty();
 
 private:
     int  openPty();
 
 private:
 
     char m_ptynam[16]; // "/dev/ptyxx" | "/dev/ptmx"
     char m_ttynam[16]; // "/dev/ttyxx" | "/dev/pts/########..."
     int m_fd;
     int m_cpid;
     QSocketNotifier* m_sn_e;
+    QSocketNotifier* m_sn_r;
 };
 
 #endif
diff --git a/noncore/apps/opie-console/io_layer.h b/noncore/apps/opie-console/io_layer.h
index 5f2fa3c..4977e94 100644
--- a/noncore/apps/opie-console/io_layer.h
+++ b/noncore/apps/opie-console/io_layer.h
@@ -1,105 +1,119 @@
 #ifndef OPIE_IO_LAYER_H
 #define OPIE_IO_LAYER_H
 
+#include <qbitarray.h>
 #include <qobject.h>
+
+
 #include <qpe/config.h>
 
 #include "profile.h"
 
 /**
  * This is the base class for IO Layers
  * It will used to sent and recv data( QByteArray )
  * it
  */
 class IOLayer : public QObject {
     Q_OBJECT
 public:
     enum Error {
         NoError = -1,
         Refuse = 0,
         CouldNotOpen =1,
         ClosedUnexpected =2,
         ClosedError =3,
         Terminate = 4
         /* add more errors here */
     };
+    enum Feature {
+        AutoConnect = 0,
+        TransferFile =1,
+        Close =2
+    };
     /**
      * a small c'tor
      */
     IOLayer();
 
     /**
      * create an IOLayer instance from a config file
      * the currently set group stores the profile/session
      * information
      */
     IOLayer( const Profile& );
 
     /**
      * destructor
      */
     virtual ~IOLayer();
 
     /**
      * a small internal identifier
      */
     virtual QString identifier() const = 0;
 
     /**
      * a short name
      */
     virtual QString name() const = 0;
 
     /**
      * a file descriptor which opens
      * the device for io but does not
      * do any ioctling on it...
      * and it'll stop listening to the before opened
      * device
      */
     virtual int rawIO()const;
 
     /**
      * will close the rawIO stuff
      * and will listen to it's data again...
      */
     virtual void closeRawIO(int);
 
+    /**
+     * What does the IOLayer support?
+     * Bits are related to features
+     */
+    virtual QBitArray supports()const = 0;
 
 signals:
     /**
      * received input as QCString
      */
     virtual void received( const QByteArray& );
 
     /**
      * an error occured
      * int for the error number
      * and QString for a text
      */
     virtual void error( int, const QString& );
 
+    virtual void closed();
 public slots:
     /**
      * send a QCString to the device
      */
     virtual void send( const QByteArray& ) = 0;
 
     /**
      * bool open
      */
     virtual bool open() = 0;
 
     /**
      * close the io
      */
     virtual void close() = 0;
 
     /**
      * closes and reloads the settings
      */
     virtual void reload( const Profile& ) = 0;
 
     /**
      * set the size
      * needed for pty
diff --git a/noncore/apps/opie-console/io_serial.cpp b/noncore/apps/opie-console/io_serial.cpp
index a4a6f0b..c10d5a8 100644
--- a/noncore/apps/opie-console/io_serial.cpp
+++ b/noncore/apps/opie-console/io_serial.cpp
@@ -166,24 +166,31 @@ QString IOSerial::identifier() const {
     return "serial";
 }
 
 QString IOSerial::name() const {
     return "RS232 Serial IO Layer";
 }
 int IOSerial::rawIO()const {
     if (m_read )
         disconnect(m_read, SIGNAL(activated(int)), this, SLOT(dataArrived()));
     if (m_error )
         disconnect(m_error, SIGNAL(activated(int)), this, SLOT(errorOccured()));
 
     int fd = ::open(m_device, O_RDWR  );
 
     return fd;
 };
 void IOSerial::closeRawIO(int fd) {
     if (m_read )
         connect(m_read, SIGNAL(activated(int)), this, SLOT(dataArrived()));
     if (m_error )
         connect(m_error, SIGNAL(activated(int)), this, SLOT(errorOccured()));
 
     ::close( fd );
 }
+QBitArray IOSerial::supports()const {
+    QBitArray ar(3);
+    ar[0] = ar[2] = 0;
+    ar[1] = 1;
+
+    return ar;
+}
diff --git a/noncore/apps/opie-console/io_serial.h b/noncore/apps/opie-console/io_serial.h
index facbbc1..b1d1be1 100644
--- a/noncore/apps/opie-console/io_serial.h
+++ b/noncore/apps/opie-console/io_serial.h
@@ -16,50 +16,52 @@
 
 class IOSerial : public IOLayer {
     Q_OBJECT
 public:
     enum Parity {
         ParityNone = 0,
         ParityEven,
         ParityOdd,
         ParitySpace,
         ParityMark
     };
 
     enum Flow {
         FlowHW = 0x01,
         FlowSW = 0x02
     };
 
     IOSerial(const Profile &);
     ~IOSerial();
 
     QString identifier() const;
     QString name() const;
     int rawIO()const;
     void closeRawIO(int fd );
-signals:
+    QBitArray supports()const;
+/*signals:
     void received(const QByteArray &);
     void error(int, const QString &);
+*/
 public slots:
     void send(const QByteArray &);
     bool open();
     void close();
     void reload(const Profile &);
 protected:
     int baud(int baud) const;
 protected slots:
     void dataArrived();
     void errorOccured();
 protected:
     QSocketNotifier *m_read;
     QSocketNotifier *m_error;
     QString          m_device;
     int              m_baud;
     int              m_parity;
     int              m_dbits;
     int              m_sbits;
     int              m_flow;
     int              m_fd;
 };
 
 #endif /* OPIE_IO_SERIAL */
diff --git a/noncore/apps/opie-console/mainwindow.cpp b/noncore/apps/opie-console/mainwindow.cpp
index 94c99bc..29dbcf3 100644
--- a/noncore/apps/opie-console/mainwindow.cpp
+++ b/noncore/apps/opie-console/mainwindow.cpp
@@ -339,121 +339,123 @@ void MainWindow::slotTerminate() {
 
 void MainWindow::slotConfigure() {
     ConfigDialog conf( manager()->all(), factory() );
     conf.showMaximized();
 
     int ret = conf.exec();
 
     if ( QDialog::Accepted == ret ) {
         manager()->setProfiles( conf.list() );
         manager()->save();
         populateProfiles();
     }
 }
 /*
  * we will remove
  * this window from the tabwidget
  * remove it from the list
  * delete it
  * and set the currentSession()
  */
 void MainWindow::slotClose() {
     if (!currentSession() )
         return;
 
+    Session* ses = currentSession();
+    qWarning("removing! currentSession %s", currentSession()->name().latin1() );
     tabWidget()->remove( currentSession() );
     /*it's autodelete */
-    m_sessions.remove( m_curSession );
-    m_curSession = m_sessions.first();
-    tabWidget()->setCurrent( m_curSession );
+    m_sessions.remove( ses );
+    qWarning("after remove!!");
 
     if (!currentSession() ) {
         m_connect->setEnabled( false );
         m_disconnect->setEnabled( false );
         m_terminate->setEnabled( false );
         m_transfer->setEnabled( false );
         m_recordScript->setEnabled( false );
         m_saveScript->setEnabled( false );
         m_runScript->setEnabled( false );
         m_fullscreen->setEnabled( false );
         m_closewindow->setEnabled( false );
     }
 }
 
 /*
  * We will get the name
  * Then the profile
  * and then we will make a profile
  */
 void MainWindow::slotProfile( int id) {
     Profile prof = manager()->profile( m_sessionsPop->text( id)  );
     create( prof );
 }
 void MainWindow::create( const Profile& prof ) {
     Session *ses = manager()->fromProfile( prof, tabWidget() );
 
     if((!ses) || (!ses->layer()) || (!ses->widgetStack()))
 	{
 		QMessageBox::warning(this,
 			QObject::tr("Session failed"),
-			QObject::tr("Cannot open session: Not all components were found."));
+			QObject::tr("<qt>Cannot open session: Not all components were found.</qt>"));
 		//if(ses) delete ses;
 		return;
 	}
 
     m_sessions.append( ses );
     tabWidget()->add( ses );
     m_curSession = ses;
 
     // dicide if its a local term ( then no connction and no tranfer), maybe make a wrapper method out of it
     m_connect->setEnabled( true );
     m_disconnect->setEnabled( false );
     m_terminate->setEnabled( true );
     m_transfer->setEnabled( true );
     m_recordScript->setEnabled( true );
     m_saveScript->setEnabled( true );
     m_runScript->setEnabled( true );
     m_fullscreen->setEnabled( true );
     m_closewindow->setEnabled( true );
 }
 
 void MainWindow::slotTransfer()
 {
     if ( currentSession() ) {
 	TransferDialog dlg(this);
 	dlg.showMaximized();
 	dlg.exec();
     }
 }
 
 
 void MainWindow::slotOpenKeb(bool state) {
 
     if (state) m_keyBar->show();
     else m_keyBar->hide();
 
 }
 void MainWindow::slotSessionChanged( Session* ses ) {
+    qWarning("changed!");
     if ( ses ) {
         m_curSession = ses;
 
         if ( m_curSession->isConnected() ) {
             m_connect->setEnabled( false );
             m_disconnect->setEnabled( true );
         } else {
             m_connect->setEnabled( true );
             m_disconnect->setEnabled( false );
         }
     }
 }
 
 void MainWindow::slotFullscreen() {
 
     if ( m_isFullscreen ) {
         ( m_curSession->widgetStack() )->reparent( m_consoleWindow, 0, QPoint(0,0), false );
         ( m_curSession->widgetStack() )->setFrameStyle( QFrame::Panel | QFrame::Sunken );
         setCentralWidget( m_consoleWindow );
         ( m_curSession->widgetStack() )->show();
         m_fullscreen->setText( tr("Full screen") );
 
     } else {
         ( m_curSession->widgetStack() )->setFrameStyle( QFrame::NoFrame );
diff --git a/noncore/apps/opie-console/profilemanager.cpp b/noncore/apps/opie-console/profilemanager.cpp
index e5aedb6..7c15560 100644
--- a/noncore/apps/opie-console/profilemanager.cpp
+++ b/noncore/apps/opie-console/profilemanager.cpp
@@ -1,28 +1,29 @@
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <qfile.h>
+#include <qhbox.h>
 #include <qlayout.h>
 #include <qwidgetstack.h>
 
 #include <qpe/config.h>
 
 #include "emulation_handler.h"
 #include "widget_layer.h"
 #include "emulation_widget.h"
 #include "metafactory.h"
 #include "profileconfig.h"
 #include "profilemanager.h"
 
 ProfileManager::ProfileManager( MetaFactory* fact )
     : m_fact( fact )
 {
 
 }
 ProfileManager::~ProfileManager() {
 
 }
 void ProfileManager::load() {
     m_list.clear();
     ProfileConfig conf("opie-console-profiles");
     QStringList groups = conf.groups();
@@ -64,61 +65,53 @@ Profile::ValueList ProfileManager::all()const {
  * add "Widget" to the layout
  * add the dummy to the stack
  * raise the dummy
  * call session->connect(=
  * this way we only need to reparent
  * in TabWidget
  */
 Session* ProfileManager::fromProfile( const Profile& prof,  QWidget* parent) {
 /* TEST PROFILE!!!
     Profile prof;
     QString str = "/dev/ttyS0";
     prof.writeEntry("Device",str );
     prof.writeEntry("Baud", 115200 );
     prof.setIOLayer("serial");
     prof.setName( "test");
 */
     Session* session = new Session();
     session->setName( prof.name() );
     /* translate the internal name to the external */
     session->setIOLayer(m_fact->newIOLayer( m_fact->external(prof.ioLayerName()) ,
                                             prof) );
 
     QWidgetStack *stack = new QWidgetStack( parent );
     session->setWidgetStack( stack );
-    QWidget* dummy = new QWidget( stack );
-    QHBoxLayout* lay = new QHBoxLayout( dummy );
-    stack->addWidget( dummy, 0 );
-    stack->raiseWidget( 0 );
+    QWidget* dummy = new QHBox( stack );
+    stack->raiseWidget( dummy );
+
     EmulationHandler* handler = new EmulationHandler(prof,dummy );
     session->setEmulationHandler( handler );
-    lay->addWidget( handler->widget() );
-//    WidgetLayer* wid = new EmulationWidget( prof, dummy );
-//    lay->addWidget( wid );
-
-//    session->setEmulationWidget( wid );
-//    session->setEmulationLayer( m_fact->newEmulationLayer( m_fact->external( prof.terminalName() ),
-//                                                        wid ) );
     session->connect();
 
     return session;
 }
 void ProfileManager::save(  ) {
     QFile::remove( (QString(getenv("HOME") )+ "/Settings/opie-console-profiles.conf" ) );
     ProfileConfig conf("opie-console-profiles");
     Profile::ValueList::Iterator it2;
     for (it2 = m_list.begin(); it2 != m_list.end(); ++it2 ) {
         conf.setGroup( (*it2).name() );
 
         /* now the config stuff */
         QMap<QString, QString> map =  (*it2).conf();
         QMap<QString, QString>::Iterator confIt;
         for ( confIt = map.begin(); confIt != map.end(); ++confIt ) {
             conf.writeEntry( confIt.key(), confIt.data() );
         }
 
         conf.writeEntry( "name", (*it2).name() );
         QString str = QString::fromUtf8( (*it2).ioLayerName() );
 
         conf.writeEntry( "iolayer", str );
         conf.writeEntry( "term", QString::fromUtf8( (*it2).terminalName()  ) );
         conf.writeEntry( "back", (*it2).background() );
diff --git a/noncore/apps/opie-console/session.cpp b/noncore/apps/opie-console/session.cpp
index e53dbc4..aad100d 100644
--- a/noncore/apps/opie-console/session.cpp
+++ b/noncore/apps/opie-console/session.cpp
@@ -15,48 +15,54 @@ Session::Session( const QString& na, QWidgetStack* widget, IOLayer* lay)
     : m_name( na ), m_widget( widget ), m_layer( lay )
 {
 //    m_widLay = 0l;
 //    m_emLay  = 0l;
     m_emu = 0l;
 }
 Session::~Session() {
     delete m_layer;
     delete m_emu;
     delete m_widget;
     /* the widget layer should be deleted by the m_widget */
 }
 QString Session::name()const {
     return m_name;
 }
 QWidgetStack* Session::widgetStack() {
     return m_widget;
 }
 IOLayer* Session::layer() {
     return m_layer;
 }
 EmulationHandler* Session::emulationHandler() {
     return m_emu;
 }
+QWidget* Session::widget() {
+    if (!m_emu )
+        return 0l;
+
+    return m_emu->widget();
+}
 /*
 WidgetLayer* Session::emulationWidget() {
     return m_widLay;
 }
 */
 void Session::connect() {
     if ( !m_layer || !m_emu )
         return;
 
     m_connected = true;
 
     QObject::connect(m_layer, SIGNAL(received(const QByteArray&) ),
             m_emu, SLOT(recv(const QByteArray&) ) );
     QObject::connect(m_emu, SIGNAL(send(const QByteArray&) ),
             m_layer, SLOT(send(const QByteArray&) ) );
 }
 
 void Session::disconnect() {
 
     if ( !m_layer || !m_emu )
         return;
 
     m_connected = false;
 
diff --git a/noncore/apps/opie-console/session.h b/noncore/apps/opie-console/session.h
index a1121d3..ff92df3 100644
--- a/noncore/apps/opie-console/session.h
+++ b/noncore/apps/opie-console/session.h
@@ -13,48 +13,49 @@ class EmulationHandler;
  */
 class Session {
 public:
     /**
      * c'tor with widget and layer
      * ownership get's transfered
      */
     Session();
     Session( const QString&, QWidgetStack* widget, IOLayer* );
     ~Session();
 
     /**
      * return the name of the session
      */
     QString name()const;
 
     /**
      * return the widgetstack
      * this is used to be semi modal
      * for FileTransfer
      *
      * semi modal == SessionModal
      */
     QWidgetStack* widgetStack();
+    QWidget* widget();
 
     /**
      * return the layer
      */
     IOLayer* layer();
 
     EmulationHandler* emulationHandler();
 
     /*
      * connects the data flow from
      * the IOLayer to the EmulationLayer
      */
     void connect();
 
     /*
      * disconnect the dataflow
      * this will be done for ft
      */
     void disconnect();
 
     void setWidgetStack( QWidgetStack* widget );
     void setEmulationHandler( EmulationHandler* lay );
     void setIOLayer( IOLayer*  );
     void setName( const QString& );
diff --git a/noncore/apps/opie-console/tabwidget.cpp b/noncore/apps/opie-console/tabwidget.cpp
index 8a691f9..419f8ac 100644
--- a/noncore/apps/opie-console/tabwidget.cpp
+++ b/noncore/apps/opie-console/tabwidget.cpp
@@ -1,37 +1,38 @@
 
 #include "tabwidget.h"
 
 TabWidget::TabWidget( QWidget* parent, const char* name )
     : OTabWidget( parent, name ) {
     connect(this, SIGNAL( currentChanged(QWidget*) ),
             this, SLOT( slotCurChanged(QWidget*) ) );
 }
 
 TabWidget::~TabWidget() {
 }
 
 void TabWidget::add( Session* ses ) {
+    qWarning("session ses " + ses->name() );
     if ( !ses->widgetStack() ) return;
     //reparent( ses->widgetStack(), QPoint() );
     addTab( ses->widgetStack(), "console/konsole", ses->name() );
     //addTab( ses->widgetStack(), ses->name() );
     m_map.insert( ses->widgetStack(), ses );
 }
 
 void TabWidget::remove( Session* ses ) {
     m_map.remove( ses->widgetStack() );
     removePage( ses->widgetStack() );
 }
 
 void TabWidget::slotCurChanged( QWidget* wid ) {
     QMap<QWidget*, Session*>::Iterator it;
     it = m_map.find( wid );
     if ( it == m_map.end() ) {
         return;
     }
 
     emit activated( it.data() );
 }
 void TabWidget::setCurrent( Session* ses ) {
     if (!ses )
         return;