Add a Feature Support BitArray to the IOLayer

This way we know what an IOLayer supports
Adjust IOSerial and MyPty to that change

Fix the after close window the previous session
window is empty bug
in Mainwindow::remove we had a problem
first we removed the currentSession from the tab and then
deleted the session
The problem is that removePage on OTabWidget does signal currentChanged
so we did not delete the session intended but the wrong one
because m_curSession got adjusted after a removePage...

3rd fix the close and reopen bug in MyPty

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
@@ -56,254 +56,269 @@
     simultanous instances of this class is (globally) limited by the number of
     those device pairs, which is 256.
 
     Another technic are UNIX 98 PTY's. These are supported also, and prefered
     over the (obsolete) predecessor.
 
     There's a sinister ioctl(2), signal(2) and job control stuff
     nessesary to make everything work as it should.
 */
 
 
 #include <qapplication.h>
 #include <qsocketnotifier.h>
 #include <qstring.h>
 
 #include <stdlib.h>
 #include <stdio.h>
 #include <signal.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <termios.h>
 #include <sys/types.h>
 #include <sys/ioctl.h>
 #include <sys/wait.h>
 
 #ifdef HAVE_OPENPTY
 #include <pty.h>
 #endif
 
 #include "procctl.h"
 #include "MyPty.h"
 
 
 #undef VERBOSE_DEBUG
 
 
 /* -------------------------------------------------------------------------- */
 
 /*!
    Informs the client program about the
    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.
 */
 int MyPty::run(const char* cmd, QStrList &, const char*, int)
 {
     // This is code from the Qt DumbTerminal example
     m_cpid = fork();
 
     if ( !m_cpid ) {
 	// child - exec shell on tty
 	for (int sig = 1; sig < NSIG; sig++) signal(sig,SIG_DFL);
 	int ttyfd = ::open(m_ttynam, O_RDWR);
 	dup2(ttyfd, STDIN_FILENO);
 	dup2(ttyfd, STDOUT_FILENO);
 	dup2(ttyfd, STDERR_FILENO);
 	// should be done with tty, so close it
 	::close(ttyfd);
 	static struct termios ttmode;
 	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
@@ -1,97 +1,99 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* [MyPty.h]                 Pseudo Terminal Device                           */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* Copyright (c) 1997,1998 by Lars Doelle <lars.doelle@on-line.de>            */
 /*                                                                            */
 /* This file is part of Konsole - an X terminal for KDE                       */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*									      */
 /* Ported Konsole to Qt/Embedded                                              */
 /*									      */
 /* Copyright (C) 2000 by John Ryland <jryland@trolltech.com>                  */
 /*									      */
 /* -------------------------------------------------------------------------- */
 
 /*! \file
 */
 
 #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);
 
     /*!
         emitted when a new block of data comes in.
         \param s - the data
         \param len - the length of the block
     */
     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,110 +1,124 @@
 #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
      */
     virtual void setSize(int rows, int cols );
 };
 
 #endif
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
@@ -126,64 +126,71 @@ void IOSerial::reload(const Profile &config) {
     m_dbits = config.readNumEntry("DataBits", SERIAL_DEFAULT_DBITS);
     m_sbits = config.readNumEntry("StopBits", SERIAL_DEFAULT_SBITS);
     m_flow = config.readNumEntry("Flow", SERIAL_DEFAULT_FLOW);
 
 }
 
 int IOSerial::baud(int baud) const {
     switch (baud) {
         case 300:    return B300;    break;
         case 600:    return B600;    break;
         case 1200:   return B1200;   break;
         case 2400:   return B2400;   break;
         case 4800:   return B4800;   break;
         case 9600:   return B9600;   break;
         case 19200:  return B19200;  break;
         case 38400:  return B38400;  break;
         case 57600:  return B57600;  break;
         case 115200: return B115200; break;
     }
     return -1;
 }
 
 void IOSerial::errorOccured() {
     emit error(ClosedUnexpected, strerror(errno));
     close();
 }
 
 void IOSerial::dataArrived() {
     QByteArray array(4097);
 
     int len = read(m_fd, array.data(), 4096);
     if (len == 0)
         close();
     if (len < 0)
         return;
     array.resize( len );
     emit received(array);
 }
 
 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
@@ -1,65 +1,67 @@
 #ifndef OPIE_IO_SERIAL
 #define OPIE_IO_SERIAL
 
 #include <qsocketnotifier.h>
 #include "io_layer.h"
 
 /* Default values to be used if the profile information is incomplete */
 #define SERIAL_DEFAULT_DEVICE       "/dev/ttyS0"
 #define SERIAL_DEFAULT_BAUD         9600
 #define SERIAL_DEFAULT_PARITY       0
 #define SERIAL_DEFAULT_DBITS        8
 #define SERIAL_DEFAULT_SBITS        1
 #define SERIAL_DEFAULT_FLOW         0
 
 /* IOSerial implements a RS232 IO Layer */
 
 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
@@ -299,178 +299,180 @@ void MainWindow::slotRunScript() {
     if (currentSession()) {
         MimeTypes types;
         QStringList script;
         script << "text/plain";
         types.insert("Script", script);
         QString filename = OFileDialog::getOpenFileName(2, "/", QString::null, types);
         if (!filename.isEmpty()) {
             Script script(DocLnk(filename).file());
             currentSession()->emulationLayer()->runScript(&script);
         }
     }
     */
 }
 
 void MainWindow::slotConnect() {
     if ( currentSession() ) {
         bool ret = currentSession()->layer()->open();
         if(!ret) QMessageBox::warning(currentSession()->widgetStack(),
                                       QObject::tr("Failed"),
                                       QObject::tr("Connecting failed for this session."));
         m_connect->setEnabled( false );
         m_disconnect->setEnabled( true );
     }
 }
 
 void MainWindow::slotDisconnect() {
     if ( currentSession() ) {
         currentSession()->layer()->close();
         m_connect->setEnabled( true );
         m_disconnect->setEnabled( false );
     }
 }
 
 void MainWindow::slotTerminate() {
     if ( currentSession() )
         currentSession()->layer()->close();
 
     slotClose();
     /* FIXME move to the next session */
 }
 
 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 );
         ( m_curSession->widgetStack() )->reparent( 0,WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop,
                                                    QPoint(0,0), false);
         ( m_curSession->widgetStack() )->resize(qApp->desktop()->width(), qApp->desktop()->height());
         ( m_curSession->widgetStack() )->setFocus();
         ( m_curSession->widgetStack() )->show();
 
         //QPushButton *cornerButton = new QPushButton( );
         //cornerButton->setPixmap( QPixmap( (const char**)menu_xpm ) );
         //connect( cornerButton, SIGNAL( pressed() ), this, SLOT( slotFullscreen() ) );
         // need teh scrollbar
         //          ( m_curSession->widgetStack() )->setCornerWidget( cornerButton );
         m_fullscreen->setText( tr("Stop full screen") );
     }
 
     m_isFullscreen = !m_isFullscreen;
 
 }
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,142 +1,135 @@
 #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();
     QStringList::Iterator it;
 
     /*
      * for each profile
      */
     for ( it = groups.begin(); it != groups.end(); ++it ) {
         conf.setGroup( (*it) );
         Profile prof;
         prof.setName( conf.readEntry("name") );
         prof.setIOLayer( conf.readEntry("iolayer").utf8() );
         prof.setTerminalName( conf.readEntry("term").utf8() );
         prof.setBackground( conf.readNumEntry("back") );
         prof.setForeground( conf.readNumEntry("fore") );
         prof.setTerminal( conf.readNumEntry("terminal") );
 
         // THIS is evil because all data get's reset
         prof.setConf( conf.items( (*it) ) );
 
         /* now add it */
         m_list.append( prof );
     }
 
 }
 void ProfileManager::clear() {
     m_list.clear();
 }
 Profile::ValueList ProfileManager::all()const {
     return m_list;
 }
 /*
  * Our goal is to create a Session
  * We will load the the IOLayer and EmulationLayer
  * from the factory
  * we will generate a QWidgetStack
  * add a dummy widget with layout
  * 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() );
         conf.writeEntry( "fore", (*it2).foreground() );
         conf.writeEntry( "terminal", (*it2).terminal() );
     }
 }
 void ProfileManager::setProfiles( const Profile::ValueList& list ) {
     m_list = list;
 };
 Profile ProfileManager::profile( const QString& name )const {
     Profile prof;
     Profile::ValueList::ConstIterator it;
     for ( it = m_list.begin(); it != m_list.end(); ++it ) {
         if ( name == (*it).name() ) {
             prof = (*it);
             break;
         }
     }
     return prof;
 }
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
@@ -1,99 +1,105 @@
 
 
 #include "io_layer.h"
 #include "file_layer.h"
 #include "emulation_handler.h"
 #include "session.h"
 
 
 Session::Session() {
     m_widget = 0l;
     m_layer = 0l;
     m_emu = 0l;
 }
 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;
 
     QObject::disconnect(m_layer, SIGNAL(received(const QByteArray&) ),
             m_emu, SLOT(recv(const QByteArray&) ) );
     QObject::disconnect(m_emu, SIGNAL(send(const QByteArray&) ),
             m_layer, SLOT(send(const QByteArray&) ) );
 }
 
 void Session::setName( const QString& na){
     m_name = na;
 }
 
 void Session::setWidgetStack( QWidgetStack* wid ) {
     delete m_emu;
     m_emu = 0l;
     delete m_widget;
     /* the EmulationLayer was destroyed... */
 
     m_widget = wid;
 }
 void Session::setIOLayer( IOLayer* lay ) {
     delete m_layer;
     m_layer = lay;
 }
 
 void Session::setEmulationHandler( EmulationHandler* lay ) {
     delete m_emu;
     m_emu = lay;
 }
 /*
 void Session::setEmulationWidget( WidgetLayer* lay ) {
     delete m_widLay;
     m_widLay = lay;
 }
 */
 
 bool Session::isConnected() {
     return  m_connected;
 }
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
@@ -1,73 +1,74 @@
 #ifndef OPIE_SESSION_H
 #define OPIE_SESSION_H
 
 #include <qwidgetstack.h>
 
 class IOLayer;
 class EmulationHandler;
 /**
  * This is a Session. A session contains
  * a QWidget pointer and a IOLayer
  * Imagine a session like a collection of what
  * is needed to show your widget in a tab ;)
  */
 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& );
 
     bool isConnected();
 
 private:
     QString m_name;
     QWidgetStack* m_widget;
     IOLayer* m_layer;
     EmulationHandler* m_emu;
     bool m_connected;
 
 };
 
 #endif
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,43 +1,44 @@
 
 #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;
 
     //showPage( ses->widgetStack() );
     setCurrentTab( ses->widgetStack() );
 }