7 files changed, 178 insertions, 5 deletions

diff --git a/noncore/apps/opie-console/emulation_layer.cpp b/noncore/apps/opie-console/emulation_layer.cpp
index 5baf05c..265c11f 100644
--- a/noncore/apps/opie-console/emulation_layer.cpp
+++ b/noncore/apps/opie-console/emulation_layer.cpp
@@ -14,339 +14,375 @@
         /*                                                                    */
 /* Copyright (C) 2000 by John Ryland <jryland@trolltech.com>                  */
         /*                                                                    */
 /* -------------------------------------------------------------------------- */
         /*                                                                    */
 /* Modified to suit opie-console                                              */
         /*                                                                    */
 /* Copyright (C) 2002 by opie developers <opie@handhelds.org>                 */
         /*                                                                    */
 /* -------------------------------------------------------------------------- */
 
 /*! \class EmulationLayer
 
     \brief Mediator between Widget and Screen.
 
    This class is responsible to scan the escapes sequences of the terminal
    emulation and to map it to their corresponding semantic complements.
    Thus this module knows mainly about decoding escapes sequences and
    is a stateless device w.r.t. the semantics.
 
    It is also responsible to refresh the Widget by certain rules.
 
    \sa Widget \sa Screen
 
    \par A note on refreshing
 
    Although the modifications to the current screen image could immediately
    be propagated via `Widget' to the graphical surface, we have chosen
    another way here.
 
    The reason for doing so is twofold.
 
    First, experiments show that directly displaying the operation results
    in slowing down the overall performance of emulations. Displaying
    individual characters using X11 creates a lot of overhead.
 
    Second, by using the following refreshing method, the screen operations
    can be completely separated from the displaying. This greatly simplifies
    the programmer's task of coding and maintaining the screen operations,
    since one need not worry about differential modifications on the
    display affecting the operation of concern.
 
    We use a refreshing algorithm here that has been adoped from rxvt/kvt.
 
    By this, refreshing is driven by a timer, which is (re)started whenever
    a new bunch of data to be interpreted by the emulation arives at `onRcvBlock'.
    As soon as no more data arrive for `BULK_TIMEOUT' milliseconds, we trigger
    refresh. This rule suits both bulk display operation as done by curses as
    well as individual characters typed.
    (BULK_TIMEOUT < 1000 / max characters received from keyboard per second).
 
    Additionally, we trigger refreshing by newlines comming in to make visual
    snapshots of lists as produced by `cat', `ls' and likely programs, thereby
    producing the illusion of a permanent and immediate display operation.
 
    As a sort of catch-all needed for cases where none of the above
    conditions catch, the screen refresh is also triggered by a count
    of incoming bulks (`bulk_incnt').
 */
 
 /* FIXME
    - evtl. the bulk operations could be made more transparent.
 */
 
 #include "emulation_layer.h"
 #include "widget_layer.h"
 #include "screen.h"
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <qkeycode.h>
 
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                               EmulationLayer                                  */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 #define CNTL(c) ((c)-'@')
 
 /*!
 */
 
 EmulationLayer::EmulationLayer( WidgetLayer* gui )
 : decoder((QTextDecoder*)NULL)
 {
   this->gui = gui;
 
   screen[0] = new Screen(gui->lines(),gui->columns());
   screen[1] = new Screen(gui->lines(),gui->columns());
   scr = screen[0];
 
   bulk_nlcnt = 0; // reset bulk newline counter
   bulk_incnt = 0; // reset bulk counter
   connected  = FALSE;
+  m_script = 0;
 
   QObject::connect(&bulk_timer, SIGNAL( timeout() ), this, SLOT( showBulk() ) );
   QObject::connect(gui,SIGNAL( imageSizeChanged( int, int ) ),
                    this,SLOT( onImageSizeChange( int, int ) ) );
   QObject::connect(gui,SIGNAL( changedHistoryCursor( int ) ),
                    this,SLOT( historyCursorChange( int ) ) );
   QObject::connect(gui,SIGNAL( keyPressed( QKeyEvent* ) ),
                    this,SLOT( onKeyPress( QKeyEvent* ) ) );
   QObject::connect(gui,SIGNAL( selectionBegin( const int, const int) ),
                    this,SLOT( onSelectionBegin( const int, const int ) ) );
   QObject::connect(gui,SIGNAL( selectionExtended( const int, const int ) ),
                    this,SLOT( onSelectionExtend( const int,const int ) ) );
   QObject::connect(gui,SIGNAL( selectionEnd( const bool ) ),
                    this,SLOT( setSelection( const bool ) ) );
   QObject::connect(gui,SIGNAL( selectionCleared() ),
                    this,SLOT( clearSelection() ) );
 }
 
 /*!
 */
 
 EmulationLayer::~EmulationLayer()
 {
   delete screen[0];
   delete screen[1];
+  if (isRecording())
+    clearScript();
   bulk_timer.stop();
 }
 
 /*! change between primary and alternate screen
 */
 
 void EmulationLayer::setScreen(int n)
 {
   scr = screen[n&1];
 }
 
 void EmulationLayer::setHistory(bool on)
 {
   screen[0]->setScroll(on);
   if (!connected) return;
   showBulk();
 }
 
 bool EmulationLayer::history()
 {
   return screen[0]->hasScroll();
 }
 
 void EmulationLayer::setCodec(int c)
 {
   //FIXME: check whether we have to free codec
   codec = c ? QTextCodec::codecForName("utf8")
             : QTextCodec::codecForLocale();
   if (decoder) delete decoder;
   decoder = codec->makeDecoder();
 }
 
 void EmulationLayer::setKeytrans(int no)
 {
   keytrans = KeyTrans::find(no);
 }
 
 void EmulationLayer::setKeytrans(const char * no)
 {
   keytrans = KeyTrans::find(no);
 }
 
 // Interpreting Codes ---------------------------------------------------------
 
 /*
    This section deals with decoding the incoming character stream.
    Decoding means here, that the stream is first seperated into `tokens'
    which are then mapped to a `meaning' provided as operations by the
    `Screen' class.
 */
 
 /*!
 */
 
 void EmulationLayer::onRcvChar(int c)
 // process application unicode input to terminal
 // this is a trivial scanner
 {
   c &= 0xff;
   switch (c)
   {
     case '\b'      : scr->BackSpace();                 break;
     case '\t'      : scr->Tabulate();                  break;
     case '\n'      : scr->NewLine();                   break;
     case '\r'      : scr->Return();                    break;
     case 0x07      : gui->bell();                      break;
     default        : scr->ShowCharacter(c);            break;
   };
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Keyboard Handling                             */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /*!
 */
 
 void EmulationLayer::onKeyPress( QKeyEvent* ev )
 {
   if (!connected) return; // someone else gets the keys
   if (scr->getHistCursor() != scr->getHistLines());
     scr->setHistCursor(scr->getHistLines());
   if (!ev->text().isEmpty())
   { // A block of text
     // Note that the text is proper unicode.
     // We should do a conversion here, but since this
     // routine will never be used, we simply emit plain ascii.
     sendString( ev->text().ascii() ); //,ev->text().length());
   }
   else if (ev->ascii()>0)
   {
     QByteArray c = QByteArray( 1 );
     c.at( 0 ) = ev->ascii();
     // ibot: qbytearray is emited not char*
+    
+    /* Are we currently recording a script? If so, store the typed character */
+    if (isRecording())
+        m_script->appendString(ev->text());
     emit sndBlock( (QByteArray) c );
   }
 }
 
 // Unblocking, Byte to Unicode translation --------------------------------- --
 
 /*
    We are doing code conversion from locale to unicode first.
 */
 
 void EmulationLayer::onRcvBlock(const QByteArray &s )
 {
   bulkStart();
   bulk_incnt += 1;
   for (int i = 0; i < s.size(); i++)
   {
     //TODO: ibot: maybe decoding qbytearray to unicode in io_layer? 
     QString result = decoder->toUnicode(&s[i],1);
     int reslen = result.length();
     for (int j = 0; j < reslen; j++)
       onRcvChar(result[j].unicode());
     if (s[i] == '\n') bulkNewline();
   }
   bulkEnd();
 }
 
+// Scripts ----------------------------------------------------------------- --
+
+
+Script *EmulationLayer::script() {
+    return m_script;
+}
+
+bool EmulationLayer::isRecording() {
+    return (m_script != 0);
+}
+
+void EmulationLayer::startRecording() {
+    if (!isRecording())
+        m_script = new Script();
+}
+
+void EmulationLayer::clearScript() {
+    if (isRecording()) {
+        
+    }
+}
+
+void EmulationLayer::runScript(const Script *script) {
+    QByteArray a = QByteArray();
+    QString str = script->script();
+    a.setRawData(str.ascii(), str.length());
+    emit sndBlock(a);
+}
+
 // Selection --------------------------------------------------------------- --
 
 void EmulationLayer::onSelectionBegin(const int x, const int y) {
   if (!connected) return;
   scr->setSelBeginXY(x,y);
   showBulk();
 }
 
 void EmulationLayer::onSelectionExtend(const int x, const int y) {
   if (!connected) return;
   scr->setSelExtentXY(x,y);
   showBulk();
 }
 
 void EmulationLayer::setSelection(const BOOL preserve_line_breaks) {
   if (!connected) return;
   QString t = scr->getSelText(preserve_line_breaks);
   if (!t.isNull()) gui->setSelection(t);
 }
 
 void EmulationLayer::clearSelection() {
   if (!connected) return;
   scr->clearSelection();
   showBulk();
 }
 
 // Refreshing -------------------------------------------------------------- --
 
 #define BULK_TIMEOUT 20
 
 /*!
    called when \n comes in. Evtl. triggers showBulk at endBulk
 */
 
 void EmulationLayer::bulkNewline()
 {
   bulk_nlcnt += 1;
   bulk_incnt = 0;  // reset bulk counter since `nl' rule applies
 }
 
 /*!
 */
 
 void EmulationLayer::showBulk()
 {
   bulk_nlcnt = 0;                       // reset bulk newline counter
   bulk_incnt = 0;                       // reset bulk counter
   if (connected)
   {
     QArray<Character> image = scr->getCookedImage();    // get the image
     gui->setImage(image,
                   scr->getLines(),
                   scr->getColumns());     // actual refresh
     delete image;
     //FIXME: check that we do not trigger other draw event here.
     gui->setScroll(scr->getHistCursor(),scr->getHistLines());
   }
 }
 
 void EmulationLayer::bulkStart()
 {
   if (bulk_timer.isActive()) bulk_timer.stop();
 }
 
 void EmulationLayer::bulkEnd()
 {
   if ( bulk_nlcnt > gui->lines() || bulk_incnt > 20 )
     showBulk();                         // resets bulk_??cnt to 0, too.
   else
     bulk_timer.start(BULK_TIMEOUT,TRUE);
 }
 
 void EmulationLayer::setConnect(bool c)
 {
   connected = c;
   if ( connected)
   {
     onImageSizeChange(gui->lines(), gui->columns());
     showBulk();
   }
   else
   {
     scr->clearSelection();
   }
 }
 
 // ---------------------------------------------------------------------------
 
 /*!  triggered by image size change of the Widget `gui'.
 
     This event is simply propagated to the attached screens
     and to the related serial line.
 */
 
 void EmulationLayer::onImageSizeChange(int lines, int columns)
 {
diff --git a/noncore/apps/opie-console/emulation_layer.h b/noncore/apps/opie-console/emulation_layer.h
index 91a4856..928ad04 100644
--- a/noncore/apps/opie-console/emulation_layer.h
+++ b/noncore/apps/opie-console/emulation_layer.h
@@ -1,146 +1,163 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* [emulation.h]          Fundamental Terminal Emulation                      */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* 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>                  */
         /*                                                                    */
 /* -------------------------------------------------------------------------- */
 /* -------------------------------------------------------------------------- */
         /*                                                                    */
 /* made to a layer between io_layer and widget                                */
         /*                                                                    */
 /* Copyright (C) 2002 by opie developers <opie@handhelds.org>                 */
         /*                                                                    */
 /* -------------------------------------------------------------------------- */
 
 #ifndef EMULATION_LAYER_H
 #define EMULATION_LAYER_H
 
 #include "widget_layer.h"
 #include "screen.h"
 #include <qtimer.h>
 #include <stdio.h>
 #include <qtextcodec.h>
 #include "keytrans.h"
+#include "script.h"
 
 class EmulationLayer : public QObject
 { Q_OBJECT
 
 public:
 
   EmulationLayer( WidgetLayer* gui );
   ~EmulationLayer();
 
 public:
   virtual void setHistory(bool on);
   virtual bool history();
 
 public slots: // signals incoming from Widget
 
   virtual void onImageSizeChange(int lines, int columns);
   virtual void onHistoryCursorChange(int cursor);
   virtual void onKeyPress(QKeyEvent*);
  
   virtual void clearSelection();
   virtual void onSelectionBegin(const int x, const int y);
   virtual void onSelectionExtend(const int x, const int y);
   virtual void setSelection(const bool preserve_line_breaks);
 
 public slots: // signals incoming from data source
 
   /**
    * to be called, when new data arrives
    */
   void onRcvBlock(const QByteArray&);
 
 signals:
   
   /**
    * will send data, encoded to suit emulation
    */
   void sndBlock(const QByteArray&);
 
   void ImageSizeChanged(int lines, int columns);
 
   void changeColumns(int columns);
 
   void changeTitle(int arg, const char* str);
 
 
 public:
 
   /**
    * process single char (decode)
    */
   virtual void onRcvChar(int);
 
   virtual void setMode  (int) = 0;
   virtual void resetMode(int) = 0;
 
   /**
    * @deprecated use qbytearray instead
    */
   virtual void sendString(const char*) = 0;
   
   /**
    * sends a string to IOLayer
    * encodes to suit emulation before
    */
   virtual void sendString(const QByteArray&) = 0;
 
   virtual void setConnect(bool r);
   void setColumns(int columns);
 
   void setKeytrans(int no);
   void setKeytrans(const char * no);
 
+  /* Scripts */
+
+  /* Create a new script and record all typed characters */
+  void startRecording();
+
+  /* Return whether we are currently recording a script */
+  bool isRecording();
+
+  /* Return the current script (or NULL) */
+  Script *script();
+
+  /* Stop recording and remove the current script from memory */
+  void clearScript();
+
+  /* Run a script by forwarding its keys to the EmulationLayer */
+  void runScript(const Script *);
 protected:
 
   WidgetLayer* gui;
   Screen* scr;         // referes to one `screen'
   Screen* screen[2];   // 0 = primary, 1 = alternate
   void setScreen(int n); // set `scr' to `screen[n]'
 
   bool   connected;    // communicate with widget
 
   void setCodec(int c); // codec number, 0 = locale, 1=utf8
 
   QTextCodec* codec;
   QTextCodec* localeCodec;
   QTextDecoder* decoder;
 
   KeyTrans* keytrans;
 
 // refreshing related material.
 // this is localized in the class.
 private slots: // triggered by timer
 
   void showBulk();
 
 private:
 
   void bulkNewline();
   void bulkStart();
   void bulkEnd();
 
 private:
 
   QTimer bulk_timer;
   int    bulk_nlcnt;   // bulk newline counter
   char*  SelectedText;
   int    bulk_incnt;   // bulk counter
-
+  Script *m_script;
 
 };
 
 #endif // ifndef EMULATION_H
diff --git a/noncore/apps/opie-console/mainwindow.cpp b/noncore/apps/opie-console/mainwindow.cpp
index 8f5d56b..46c5bed 100644
--- a/noncore/apps/opie-console/mainwindow.cpp
+++ b/noncore/apps/opie-console/mainwindow.cpp
@@ -1,275 +1,329 @@
 
 #include <qaction.h>
 #include <qmenubar.h>
 #include <qlabel.h>
 #include <qpopupmenu.h>
 #include <qtoolbar.h>
 #include <qpe/resource.h>
-
+#include <opie/ofiledialog.h>
 
 #include "profileeditordialog.h"
 #include "configdialog.h"
 #include "default.h"
 #include "metafactory.h"
 #include "profile.h"
 #include "profilemanager.h"
 #include "mainwindow.h"
 #include "tabwidget.h"
 #include "transferdialog.h"
 #include "function_keyboard.h"
+#include "script.h"
 
 MainWindow::MainWindow() {
     m_factory = new MetaFactory();
     Default def(m_factory);
     m_sessions.setAutoDelete( TRUE );
     m_curSession = 0;
     m_manager = new ProfileManager( m_factory );
     m_manager->load();
 
     initUI();
     populateProfiles();
 }
 void MainWindow::initUI() {
     setToolBarsMovable( FALSE  );
 
     /* tool bar for the menu */
     m_tool = new QToolBar( this );
     m_tool->setHorizontalStretchable( TRUE );
 
     m_bar = new QMenuBar( m_tool );
     m_console = new QPopupMenu( this );
+    m_scripts = new QPopupMenu( this );
     m_sessionsPop= new QPopupMenu( this );
     m_settings = new QPopupMenu( this );
 
     /* add a toolbar for icons */
     m_icons = new QToolBar(this);
 
     /*
      * new Action for new sessions
      */
     QAction* a = new QAction(tr("New Connection"),
                              Resource::loadPixmap( "new" ), 
                              QString::null, 0, this, 0);
     a->addTo( m_console );
     a->addTo( m_icons );
     connect(a, SIGNAL(activated() ),
             this, SLOT(slotNew() ) );
 
     /*
      * connect action
      */
     m_connect = new QAction();
     m_connect->setText( tr("Connect") );
     m_connect->addTo( m_console );
     connect(m_connect, SIGNAL(activated() ),
             this, SLOT(slotConnect() ) );
 
     /*
      * disconnect action
      */
     m_disconnect = new QAction();
     m_disconnect->setText( tr("Disconnect") );
     m_disconnect->addTo( m_console );
     connect(m_disconnect, SIGNAL(activated() ),
             this, SLOT(slotDisconnect() ) );
 
         m_transfer = new QAction();
         m_transfer->setText( tr("Transfer file...") );
         m_transfer->addTo( m_console );
         connect(m_transfer, SIGNAL(activated() ),
                         this, SLOT(slotTransfer() ) );
 
     /*
      * terminate action
      */
     m_terminate = new QAction();
     m_terminate->setText( tr("Terminate") );
     m_terminate->addTo( m_console );
     connect(m_terminate, SIGNAL(activated() ),
             this, SLOT(slotTerminate() ) );
 
     a = new QAction();
     a->setText( tr("Close Window") );
     a->addTo( m_console );
     connect(a, SIGNAL(activated() ),
             this, SLOT(slotClose() ) );
 
     /*
      * the settings action
      */
     m_setProfiles = new QAction(tr("Configure Profiles"),
                              Resource::loadPixmap( "SettingsIcon" ), 
                              QString::null, 0, this, 0);
     m_setProfiles->addTo( m_settings );
     m_setProfiles->addTo( m_icons );
     connect( m_setProfiles, SIGNAL(activated() ),
              this, SLOT(slotConfigure() ) );
 
     /*
+     * script actions
+     */
+    m_recordScript = new QAction(tr("Record Script"), QString::null, 0, this, 0);
+    m_recordScript->addTo(m_scripts);
+    connect(m_recordScript, SIGNAL(activated()), this, SLOT(slotRecordScript()));
+    
+    m_saveScript = new QAction(tr("Save Script"), QString::null, 0, this, 0);
+    m_saveScript->addTo(m_scripts);
+    connect(m_saveScript, SIGNAL(activated()), this, SLOT(slotSaveScript()));
+    
+    m_runScript = new QAction(tr("Run Script"), QString::null, 0, this, 0);
+    m_runScript->addTo(m_scripts);
+    connect(m_runScript, SIGNAL(activated()), this, SLOT(slotRunScript()));
+
+    /*
      * action that open/closes the keyboard
      */
     m_openKeys = new QAction (tr("Open Keyboard..."), 
                              Resource::loadPixmap( "down" ), 
                              QString::null, 0, this, 0);
 
     m_openKeys->setToggleAction(true);
 
     connect (m_openKeys, SIGNAL(toggled(bool)), 
              this, SLOT(slotOpenKeb(bool)));
     m_openKeys->addTo(m_icons);
     
 
     /* insert the submenu */
     m_console->insertItem(tr("New from Profile"), m_sessionsPop,
                           -1, 0);
 
     /* insert the connection menu */
     m_bar->insertItem( tr("Connection"), m_console );
 
+    /* the scripts menu */
+    m_bar->insertItem( tr("Scripts"), m_scripts );
+    
     /* the settings menu */
     m_bar->insertItem( tr("Settings"), m_settings );
 
     /* and the keyboard */
     m_keyBar = new QToolBar(this);
     addToolBar( m_keyBar,  "Keyboard", QMainWindow::Top, TRUE );
     m_keyBar->setHorizontalStretchable( TRUE );
     m_keyBar->hide();
 
     m_kb = new FunctionKeyboard(m_keyBar);
              
     /*
      * connect to the menu activation
      */
     connect( m_sessionsPop, SIGNAL(activated( int ) ),
              this, SLOT(slotProfile( int ) ) );
 
     m_consoleWindow = new TabWidget( this, "blah");
     setCentralWidget( m_consoleWindow );
 
 }
 
 ProfileManager* MainWindow::manager() {
     return m_manager;
 }
 TabWidget* MainWindow::tabWidget() {
     return m_consoleWindow;
 }
 void MainWindow::populateProfiles() {
     m_sessionsPop->clear();
     Profile::ValueList list = manager()->all();
     for (Profile::ValueList::Iterator it = list.begin(); it != list.end(); ++it ) {
         m_sessionsPop->insertItem( (*it).name() );
     }
 
 }
 MainWindow::~MainWindow() {
     delete m_factory;
     manager()->save();
 }
 
 MetaFactory* MainWindow::factory() {
     return m_factory;
 }
 
 Session* MainWindow::currentSession() {
     return m_curSession;
 }
 
 QList<Session> MainWindow::sessions() {
     return m_sessions;
 }
 
 void MainWindow::slotNew() {
     qWarning("New Connection");
     ProfileEditorDialog dlg(factory() );
     int ret = dlg.exec();
 
     if ( ret == QDialog::Accepted ) {
         create( dlg.profile() );
     }
 }
 
+void MainWindow::slotRecordScript() {
+    if (currentSession()) {
+        currentSession()->emulationLayer()->startRecording();
+    }
+}
+
+void MainWindow::slotSaveScript() {
+    if (currentSession() && currentSession()->emulationLayer()->isRecording()) {
+        MimeTypes types;
+        QStringList script;
+        script << "text/plain";
+        types.insert("Script", script);
+        QString filename = OFileDialog::getSaveFileName(2, "/", QString::null, types);
+        if (!filename.isEmpty()) {
+            currentSession()->emulationLayer()->script()->saveTo(filename);
+            currentSession()->emulationLayer()->clearScript();
+        }
+    }
+}
+
+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() )
         currentSession()->layer()->open();
 }
 
 void MainWindow::slotDisconnect() {
     if ( currentSession() )
         currentSession()->layer()->close();
 }
 
 void MainWindow::slotTerminate() {
     if ( currentSession() )
         currentSession()->layer()->close();
 
     slotClose();
     /* FIXME move to the next session */
 }
 
 void MainWindow::slotConfigure() {
     qWarning("configure");
     ConfigDialog conf( manager()->all(), factory() );
     conf.showMaximized();
 
     int ret = conf.exec();
 
     if ( QDialog::Accepted == ret ) {
         qWarning("conf %d", conf.list().count() );
         manager()->setProfiles( conf.list() );
         populateProfiles();
     }
 }
 /*
  * we will remove
  * this window from the tabwidget
  * remove it from the list
  * delete it
  * and set the currentSession()
  */
 void MainWindow::slotClose() {
     qWarning("close");
     if (!currentSession() )
         return;
 
     tabWidget()->remove( currentSession() );
     /*it's autodelete */
     m_sessions.remove( m_curSession );
     m_curSession = m_sessions.first();
     tabWidget()->setCurrent( m_curSession );
 }
 
 /*
  * 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() );
 
     m_sessions.append( ses );
     tabWidget()->add( ses );
     m_curSession = ses;
 
 }
 
 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();
 
 }
diff --git a/noncore/apps/opie-console/mainwindow.h b/noncore/apps/opie-console/mainwindow.h
index 73bb285..94144a4 100644
--- a/noncore/apps/opie-console/mainwindow.h
+++ b/noncore/apps/opie-console/mainwindow.h
@@ -1,102 +1,108 @@
 #ifndef OPIE_MAIN_WINDOW_H
 #define OPIE_MAIN_WINDOW_H
 
 #include <qmainwindow.h>
 #include <qlist.h>
 
 #include "session.h"
 
 /**
  * this is the MainWindow of the new opie console
  * it's also the dispatcher between the different
  * actions supported by the gui
  */
 class QToolBar;
 class QToolButton;
 class QMenuBar;
 class QAction;
 class MetaFactory;
 class TabWidget;
 class ProfileManager;
 class Profile;
 class FunctionKeyboard;
 class MainWindow : public QMainWindow {
     Q_OBJECT
 public:
     MainWindow();
     ~MainWindow();
 
     /**
      * our factory to generate IOLayer and so on
      *
      */
     MetaFactory* factory();
 
     /**
      * A session contains a QWidget*,
      * an IOLayer* and some infos for us
      */
     Session* currentSession();
 
     /**
      * the session list
      */
     QList<Session> sessions();
 
     /**
      *
      */
     ProfileManager* manager();
     TabWidget* tabWidget();
 
 private slots:
     void slotNew();
     void slotConnect();
     void slotDisconnect();
     void slotTerminate();
     void slotConfigure();
     void slotClose();
     void slotProfile(int);
         void slotTransfer();
     void slotOpenKeb(bool);
-
+    void slotRecordScript();
+    void slotSaveScript();
+    void slotRunScript();
 private:
     void initUI();
     void populateProfiles();
     void create( const Profile& );
     /**
      * the current session
      */
     Session* m_curSession;
 
     /**
      * the session list
      */
     QList<Session> m_sessions;
 
     /**
      * the metafactory
      */
     MetaFactory* m_factory;
     ProfileManager* m_manager;
 
     TabWidget* m_consoleWindow;
     QToolBar* m_tool;
     QToolBar* m_icons;
     QToolBar* m_keyBar;
     QMenuBar* m_bar;
     QPopupMenu* m_console;
     QPopupMenu* m_settings;
     QPopupMenu* m_sessionsPop;
+    QPopupMenu* m_scripts;
     QAction* m_connect;
     QAction* m_disconnect;
     QAction* m_terminate;
         QAction* m_transfer;
     QAction* m_setProfiles;
     QAction* m_openKeys;
+    QAction* m_recordScript;
+    QAction* m_saveScript;
+    QAction* m_runScript;
 
     FunctionKeyboard *m_kb;
 };
 
 
 #endif
diff --git a/noncore/apps/opie-console/opie-console.pro b/noncore/apps/opie-console/opie-console.pro
index b07f10a..8e39a48 100644
--- a/noncore/apps/opie-console/opie-console.pro
+++ b/noncore/apps/opie-console/opie-console.pro
@@ -1,68 +1,68 @@
 TEMPLATE     = app
 #CONFIG       = qt warn_on release
         CONFIG      = qt debug
 DESTDIR      = $(OPIEDIR)/bin
 HEADERS      = io_layer.h io_serial.h io_irda.h io_bt.h\
                file_layer.h filetransfer.h \
                metafactory.h \
                session.h \
                mainwindow.h \
                profile.h \
                profileconfig.h \
                profilemanager.h  \
                configwidget.h \
                tabwidget.h \
                configdialog.h \
                emulation_layer.h \
                vt102emulation.h \
                common.h \
                history.h \
                screen.h \
                keytrans.h \
                widget_layer.h \
                transferdialog.h \
                profiledialogwidget.h \
                profileeditordialog.h \
                default.h \
                terminalwidget.h \
                iolayerbase.h \
                serialconfigwidget.h irdaconfigwidget.h \
                btconfigwidget.h modemconfigwidget.h \
                atconfigdialog.h dialdialog.h \  
                emulation_widget.h procctl.h \
-           function_keyboard.h
+           function_keyboard.h script.h
 
 SOURCES      = io_layer.cpp io_serial.cpp io_irda.cpp io_bt.cpp \
                file_layer.cpp filetransfer.cpp \
                main.cpp \
                metafactory.cpp \
                session.cpp \
                mainwindow.cpp \
                profile.cpp \
                profileconfig.cpp \
                profilemanager.cpp  \
                tabwidget.cpp \
                configdialog.cpp \
                emulation_layer.cpp \
                vt102emulation.cpp \
                history.cpp \
                screen.cpp \
                keytrans.cpp \
                widget_layer.cpp \
                transferdialog.cpp \
                profiledialogwidget.cpp \
                profileeditordialog.cpp \
                terminalwidget.cpp \
                iolayerbase.cpp \
                serialconfigwidget.cpp irdaconfigwidget.cpp \
                btconfigwidget.cpp modemconfigwidget.cpp \ 
                atconfigdialog.cpp dialdialog.cpp \
                emulation_widget.cpp default.cpp  procctl.cpp \
-           function_keyboard.cpp
+           function_keyboard.cpp script.cpp
 
 INTERFACES   = configurebase.ui editbase.ui
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH  += $(OPIEDIR)/include
 LIBS        += -lqpe -lopie 
 TARGET       = opie-console
 
diff --git a/noncore/apps/opie-console/script.cpp b/noncore/apps/opie-console/script.cpp
new file mode 100644
index 0000000..a09fab6
--- a/dev/null
+++ b/noncore/apps/opie-console/script.cpp
@@ -0,0 +1,30 @@
+#include <qfile.h>
+#include <qtextstream.h>
+#include "script.h"
+
+Script::Script() {
+}
+
+Script::Script(const QString fileName) {
+    QFile file(fileName);
+    QTextStream stream(&file);
+    while (!stream.atEnd()) {
+        appendString(stream.readLine());
+    }
+}
+
+void Script::saveTo(const QString fileName) const {
+    QFile file(fileName);
+    file.open(IO_WriteOnly);
+    file.writeBlock(m_script.ascii(), m_script.length());
+    file.close();
+}
+
+
+void Script::appendString(const QString string) {
+    m_script += string;
+}
+
+QString Script::script() const {
+    return m_script;
+}
diff --git a/noncore/apps/opie-console/script.h b/noncore/apps/opie-console/script.h
new file mode 100644
index 0000000..dc2351b
--- a/dev/null
+++ b/noncore/apps/opie-console/script.h
@@ -0,0 +1,30 @@
+#ifndef CONSOLE_SCRIPT_H
+#define CONSOLE_SCRIPT_H
+
+#include <qstring.h>
+
+/* Very simple scripting - this class stores keys received
+ * by emulation_layer */
+
+class Script {
+public:
+    /* Construct an empty script */
+    Script();
+    
+    /* Load a script from a text file */
+    Script(const QString fileName);
+
+    /* Append a line to the script */
+    void appendString(const QString string);
+
+    /* Save this script to a file */
+    void saveTo(const QString fileName) const;
+
+    /* Return the script's content */
+    QString script() const;
+protected:
+    QString m_script;
+};
+
+
+#endif /* CONSOLE_SCRIPT_H */