updated emulationLayer to use WidgetLayer (not Widget, which is b0rked)

default.cpp is broken, because there is still no new widget (coming
soon...)

8 files changed, 57 insertions, 44 deletions

diff --git a/noncore/apps/opie-console/common.h b/noncore/apps/opie-console/common.h
index 979c2bd..a621ff5 100644
--- a/noncore/apps/opie-console/common.h
+++ b/noncore/apps/opie-console/common.h
@@ -1,40 +1,40 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
-/* [TECommon.h]                  Common Definitions                           */
+/* [Common.h]                  Common Definitions                           */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* 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 TECommon.h
+/*! \file Common.h
     \brief Definitions shared between TEScreen and TEWidget.
 */
 
-#ifndef TECOMMON_H
-#define TECOMMON_H
+#ifndef COMMON_H
+#define COMMON_H
 
 #include <qcolor.h>
 
 #ifndef BOOL
 typedef bool BOOL;
 #endif
 
 #ifndef FALSE
 #define FALSE 0
 #endif
 
 #ifndef TRUE
 #define TRUE 1
 #endif
 
 #ifndef UINT8
@@ -98,17 +98,17 @@ inline BOOL operator != (Character a, Character b)
 /*!
 */
 struct ColorEntry
 {
   ColorEntry(QColor c, bool tr, bool b) : color(c), transparent(tr), bold(b) {}
   ColorEntry() : transparent(false), bold(false) {} // default constructors
   void operator=(const ColorEntry& rhs) { 
        color = rhs.color; 
        transparent = rhs.transparent; 
        bold = rhs.bold; 
   }
   QColor color;
   bool   transparent; // if used on bg
   bool   bold;        // if used on fg
 };
 
-#endif // TECOMMON_H
+#endif // COMMON_H
diff --git a/noncore/apps/opie-console/emulation_layer.cpp b/noncore/apps/opie-console/emulation_layer.cpp
index 6c420e0..5baf05c 100644
--- a/noncore/apps/opie-console/emulation_layer.cpp
+++ b/noncore/apps/opie-console/emulation_layer.cpp
@@ -63,78 +63,78 @@
    (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.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(Widget* gui)
+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());
+  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;
 
   QObject::connect(&bulk_timer, SIGNAL(timeout()), this, SLOT(showBulk()) );
-  QObject::connect(gui,SIGNAL(changedImageSizeSignal(int,int)),
+  QObject::connect(gui,SIGNAL( imageSizeChanged( int, int ) ),
                    this,SLOT(onImageSizeChange(int,int)));
   QObject::connect(gui,SIGNAL(changedHistoryCursor(int)),
-                   this,SLOT(onHistoryCursorChange(int)));
-  QObject::connect(gui,SIGNAL(keyPressedSignal(QKeyEvent*)),
+                   this,SLOT( historyCursorChange( int ) ) );
+  QObject::connect(gui,SIGNAL( keyPressed( QKeyEvent* ) ),
                    this,SLOT(onKeyPress(QKeyEvent*)));
-  QObject::connect(gui,SIGNAL(beginSelectionSignal(const int,const int)),
+  QObject::connect(gui,SIGNAL( selectionBegin( const int, const int) ),
 		   this,SLOT(onSelectionBegin(const int,const int)) );
-  QObject::connect(gui,SIGNAL(extendSelectionSignal(const int,const int)),
+  QObject::connect(gui,SIGNAL( selectionExtended( const int, const int ) ),
 		   this,SLOT(onSelectionExtend(const int,const int)) );
-  QObject::connect(gui,SIGNAL(endSelectionSignal(const BOOL)),
-		   this,SLOT(setSelection(const BOOL)) );
-  QObject::connect(gui,SIGNAL(clearSelectionSignal()),
+  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];
   bulk_timer.stop();
 }
 
 /*! change between primary and alternate screen
 */
 
@@ -184,33 +184,33 @@ void EmulationLayer::setKeytrans(const char * no)
 */
 
 /*!
 */
 
 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;
+    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
@@ -290,61 +290,61 @@ void EmulationLayer::clearSelection() {
 
 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)
   {
-    Character* image = scr->getCookedImage();    // get the image
+    QArray<Character> image = scr->getCookedImage();    // get the image
     gui->setImage(image,
                   scr->getLines(),
                   scr->getColumns());     // actual refresh
-    free(image);
+    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 )
+  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());
+    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.
 */
 
diff --git a/noncore/apps/opie-console/emulation_layer.h b/noncore/apps/opie-console/emulation_layer.h
index 5781acc..91a4856 100644
--- a/noncore/apps/opie-console/emulation_layer.h
+++ b/noncore/apps/opie-console/emulation_layer.h
@@ -25,49 +25,49 @@
 
 #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"
 
 class EmulationLayer : public QObject
 { Q_OBJECT
 
 public:
 
-  EmulationLayer(Widget* gui);
+  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);
+  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);
@@ -93,33 +93,33 @@ public:
   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);
 
 protected:
 
-  Widget* gui;
+  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.
diff --git a/noncore/apps/opie-console/screen.cpp b/noncore/apps/opie-console/screen.cpp
index 8ebc47d..a796ba1 100644
--- a/noncore/apps/opie-console/screen.cpp
+++ b/noncore/apps/opie-console/screen.cpp
@@ -55,47 +55,47 @@
 #define HERE printf("%s(%d): here\n",__FILE__,__LINE__)
 
 //FIXME: this is emulation specific. Use FALSE for xterm, TRUE for ANSI.
 //FIXME: see if we can get this from terminfo.
 #define BS_CLEARS FALSE
 
 #define loc(X,Y) ((Y)*columns+(X))
 
 /*! creates a `Screen' of `lines' lines and `columns' columns.
 */
 
 Screen::Screen(int lines, int columns)
 {
   this->lines   = lines;
   this->columns = columns;
 
-  image      = (Character*) malloc(lines*columns*sizeof(Character));
+  image      = QArray<Character>( lines*columns );
   tabstops   = NULL; initTabStops();
 
   histCursor = 0;
 
   clearSelection();
   reset();
 }
 
 /*! Destructor
 */
 
 Screen::~Screen()
 {
-  free(image);
+  delete image;
   if (tabstops) free(tabstops);
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /* Normalized                    Screen Operations                           */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 // Cursor Setting --------------------------------------------------------------
 
 /*! \section Cursor
 
     The `cursor' is a location within the screen that is implicitely used in
     many operations. The operations within this section allow to manipulate
     the cursor explicitly and to obtain it's value.
@@ -381,57 +381,57 @@ void Screen::restoreCursor()
     tab positions reinitialized.
 */
 
 void Screen::resizeImage(int new_lines, int new_columns)
 {
 
   if (cuY > new_lines-1)
   { // attempt to preserve focus and lines
     bmargin = lines-1; //FIXME: margin lost
     for (int i = 0; i < cuY-(new_lines-1); i++)
     {
       addHistLine(); scrollUp(0,1);
     }
   }
 
   // make new image
-  Character* newimg = (Character*) malloc(new_lines*new_columns*sizeof(Character));
+  QArray<Character> newimg = QArray<Character>( new_lines * new_columns );
 
   clearSelection();
 
   // clear new image
   for (int y = 0; y < new_lines; y++)
   for (int x = 0; x < new_columns; x++)
   {
     newimg[y*new_columns+x].c = ' ';
     newimg[y*new_columns+x].f = DEFAULT_FORE_COLOR;
     newimg[y*new_columns+x].b = DEFAULT_BACK_COLOR;
     newimg[y*new_columns+x].r = DEFAULT_RENDITION;
   }
   int cpy_lines   = QMIN(new_lines,  lines);
   int cpy_columns = QMIN(new_columns,columns);
   // copy to new image
   for (int y = 0; y < cpy_lines; y++)
   for (int x = 0; x < cpy_columns; x++)
   {
     newimg[y*new_columns+x].c = image[loc(x,y)].c;
     newimg[y*new_columns+x].f = image[loc(x,y)].f;
     newimg[y*new_columns+x].b = image[loc(x,y)].b;
     newimg[y*new_columns+x].r = image[loc(x,y)].r;
   }
-  free(image);
+  delete image;
   image = newimg;
   lines = new_lines;
   columns = new_columns;
   cuX = QMIN(cuX,columns-1);
   cuY = QMIN(cuY,lines-1);
 
   // FIXME: try to keep values, evtl.
   tmargin=0;
   bmargin=lines-1;
   initTabStops();
   clearSelection();
 }
 
 /*
    Clarifying rendition here and in TEWidget.
 
@@ -491,33 +491,33 @@ void Screen::effectiveRendition()
       ef_fg += BASE_COLORS;
     else
       ef_fg -= BASE_COLORS;
   }
 }
 
 /*!
     returns the image.
 
     Get the size of the image by \sa getLines and \sa getColumns.
 
     NOTE that the image returned by this function must later be
     freed.
 
 */
 
-Character* Screen::getCookedImage()
+QArray<Character> Screen::getCookedImage()
 { int x,y;
   Character* merged = (Character*) malloc(lines*columns*sizeof(Character));
   Character dft(' ',DEFAULT_FORE_COLOR,DEFAULT_BACK_COLOR,DEFAULT_RENDITION);
 
   for (y = 0; (y < lines) && (y < (hist.getLines()-histCursor)); y++)
   {
     int len = QMIN(columns,hist.getLineLen(y+histCursor));
     int yp  = y*columns;
     int yq  = (y+histCursor)*columns;
 
     hist.getCells(y+histCursor,0,len,merged+yp);
     for (x = len; x < columns; x++) merged[yp+x] = dft;
     for (x = 0; x < columns; x++)
     {   int p=x + yp; int q=x + yq;
         if ( ( q >= sel_TL ) && ( q <= sel_BR ) )
           reverseRendition(&merged[p]); // for selection
@@ -534,33 +534,35 @@ Character* Screen::getCookedImage()
        { int p = x + yp; int q = x + yq; int r = x + yr;
          merged[p] = image[r];
          if ( q >= sel_TL && q <= sel_BR )
            reverseRendition(&merged[p]); // for selection
        }
 
     }
   }
   // evtl. inverse display
   if (getMode(MODE_Screen))
   { int i,n = lines*columns;
     for (i = 0; i < n; i++)
       reverseRendition(&merged[i]); // for reverse display
   }
   if (getMode(MODE_Cursor) && (cuY+(hist.getLines()-histCursor) < lines)) // cursor visible
     reverseRendition(&merged[loc(cuX,cuY+(hist.getLines()-histCursor))]);
-  return merged;
+  QArray<Character> res( sizeof( merged ) / sizeof( Character ) );
+  res.assign( merged, sizeof( merged ) / sizeof( Character ) );
+  return res;
 }
 
 
 /*!
 */
 
 void Screen::reset()
 {
     setMode(MODE_Wrap  ); saveMode(MODE_Wrap  );  // wrap at end of margin
   resetMode(MODE_Origin); saveMode(MODE_Origin);  // position refere to [1,1]
   resetMode(MODE_Insert); saveMode(MODE_Insert);  // overstroke
     setMode(MODE_Cursor);                         // cursor visible
   resetMode(MODE_Screen);                         // screen not inverse
   resetMode(MODE_NewLine);
 
   tmargin=0;
@@ -1146,33 +1148,33 @@ FIXME:
 */
 
 void Screen::addHistLine()
 {
   assert(hasScroll() || histCursor == 0);
 
   // add to hist buffer
   // we have to take care about scrolling, too...
 
   if (hasScroll())
   { Character dft;
 
     int end = columns-1;
     while (end >= 0 && image[end] == dft)
       end -= 1;
 
-    hist.addCells(image,end+1);
+    hist.addCells(image.data(), end+1);
     hist.addLine();
 
     // adjust history cursor
     histCursor += (hist.getLines()-1 == histCursor);
   }
 
   if (!hasScroll()) histCursor = 0; //FIXME: a poor workaround
 }
 
 void Screen::setHistCursor(int cursor)
 {
   histCursor = cursor; //FIXME:rangecheck
 }
 
 int Screen::getHistCursor()
 {
diff --git a/noncore/apps/opie-console/screen.h b/noncore/apps/opie-console/screen.h
index cd7422a..38b84ab 100644
--- a/noncore/apps/opie-console/screen.h
+++ b/noncore/apps/opie-console/screen.h
@@ -123,33 +123,33 @@ public: // these are all `Screen' operations
     //
     // only for report cursor position
     //
     int  getCursorX();
     int  getCursorY();
     //
     // -------------------------------------
     //
     void clear();
     void home();
     void reset();
     //
     void ShowCharacter(unsigned short c);
     //
     void resizeImage(int new_lines, int new_columns);
     //
-    Character*  getCookedImage();
+    QArray<Character> getCookedImage();
     
     /*! return the number of lines. */
     int  getLines()   { return lines; }
     /*! return the number of columns. */
     int  getColumns() { return columns; }
 
     /*! set the position of the history cursor. */
     void setHistCursor(int cursor);
     /*! return the position of the history cursor. */
     int  getHistCursor();
 
     int  getHistLines ();
     void setScroll(bool on);
     bool hasScroll();
 
     //
@@ -180,33 +180,33 @@ private: // helper
 private:
 
     /*
        The state of the screen is more complex as one would
        expect first. The screem does really do part of the
        emulation providing state informations in form of modes,
        margins, tabulators, cursor etc.
 
        Even more unexpected are variables to save and restore
        parts of the state.
     */
 
     // screen image ----------------
 
     int lines;
     int columns;
-    Character *image; // [lines][columns]
+    QArray<Character> image; // [lines][columns]
 
     // history buffer ---------------
 
     int histCursor;   // display position relative to start of the history buffer
     HistoryScroll hist;
     
     // cursor location
 
     int cuX;
     int cuY;
 
     // cursor color and rendition info
 
     UINT8 cu_fg;      // foreground
     UINT8 cu_bg;      // background
     UINT8 cu_re;      // rendition
diff --git a/noncore/apps/opie-console/vt102emulation.cpp b/noncore/apps/opie-console/vt102emulation.cpp
index 2220f4e..7eecef3 100644
--- a/noncore/apps/opie-console/vt102emulation.cpp
+++ b/noncore/apps/opie-console/vt102emulation.cpp
@@ -52,33 +52,33 @@
 */
 
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                       Constructor / Destructor                            */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /*
    Nothing really intesting happens here.
 */
 
 /*!
 */
 
-Vt102Emulation::Vt102Emulation(Widget* gui) : EmulationLayer(gui)
+Vt102Emulation::Vt102Emulation(WidgetLayer* gui) : EmulationLayer(gui)
 {
   QObject::connect(gui,SIGNAL(mouseSignal(int,int,int)),
                    this,SLOT(onMouse(int,int,int)));
   initTokenizer();
   reset();
 }
 
 /*!
 */
 
 Vt102Emulation::~Vt102Emulation()
 {
 }
 
 /*!
 */
@@ -336,33 +336,33 @@ void Vt102Emulation::tau( int token, int p, int q )
 //if (token == TY_CHR___()) printf("%c",p); else
 //printf("tau(%d,%d,%d, %d,%d)\n",(token>>0)&0xff,(token>>8)&0xff,(token>>16)&0xffff,p,q);
   switch (token)
   {
 
     case TY_CHR___(         ) : scr->ShowCharacter        (p         ); break; //UTF16
 
     //             127 DEL    : ignored on input
 
     case TY_CTL___('@'      ) : /* NUL: ignored                      */ break;
     case TY_CTL___('A'      ) : /* SOH: ignored                      */ break;
     case TY_CTL___('B'      ) : /* STX: ignored                      */ break;
     case TY_CTL___('C'      ) : /* ETX: ignored                      */ break;
     case TY_CTL___('D'      ) : /* EOT: ignored                      */ break;
     case TY_CTL___('E'      ) :      reportAnswerBack     (          ); break; //VT100
     case TY_CTL___('F'      ) : /* ACK: ignored                      */ break;
-    case TY_CTL___('G'      ) : gui->Bell                 (          ); break; //VT100
+    case TY_CTL___('G'      ) : gui->bell                 (          ); break; //VT100
     case TY_CTL___('H'      ) : scr->BackSpace            (          ); break; //VT100
     case TY_CTL___('I'      ) : scr->Tabulate             (          ); break; //VT100
     case TY_CTL___('J'      ) : scr->NewLine              (          ); break; //VT100
     case TY_CTL___('K'      ) : scr->NewLine              (          ); break; //VT100
     case TY_CTL___('L'      ) : scr->NewLine              (          ); break; //VT100
     case TY_CTL___('M'      ) : scr->Return               (          ); break; //VT100
 
     case TY_CTL___('N'      ) :      useCharset           (         1); break; //VT100
     case TY_CTL___('O'      ) :      useCharset           (         0); break; //VT100
 
     case TY_CTL___('P'      ) : /* DLE: ignored                      */ break;
     case TY_CTL___('Q'      ) : /* DC1: XON continue                 */ break; //VT100
     case TY_CTL___('R'      ) : /* DC2: ignored                      */ break;
     case TY_CTL___('S'      ) : /* DC3: XOFF halt                    */ break; //VT100
     case TY_CTL___('T'      ) : /* DC4: ignored                      */ break;
     case TY_CTL___('U'      ) : /* NAK: ignored                      */ break;
@@ -724,37 +724,37 @@ void Vt102Emulation::onKeyPress( QKeyEvent* ev )
   if (scr->getHistCursor() != scr->getHistLines());
     scr->setHistCursor(scr->getHistLines());
 
   // lookup in keyboard translation table ...
   int cmd; const char* txt; int len;
   if (keytrans->findEntry(ev->key(), encodeMode(MODE_NewLine  , BITS_NewLine   ) + // OLD,
                                      encodeMode(MODE_Ansi     , BITS_Ansi      ) + // OBSOLETE,
                                      encodeMode(MODE_AppCuKeys, BITS_AppCuKeys ) + // VT100 stuff
                                      encodeStat(ControlButton , BITS_Control   ) +
                                      encodeStat(ShiftButton   , BITS_Shift     ) +
                                      encodeStat(AltButton     , BITS_Alt       ),
                           &cmd, &txt, &len ))
 //printf("cmd: %d, %s, %d\n",cmd,txt,len);
     {
       switch(cmd) // ... and execute if found.
         {
-	case CMD_emitSelection  : gui->emitSelection();           return;
-	case CMD_scrollPageUp   : gui->doScroll(-gui->Lines()/2); return;
-	case CMD_scrollPageDown : gui->doScroll(+gui->Lines()/2); return;
-	case CMD_scrollLineUp   : gui->doScroll(-1             ); return;
-	case CMD_scrollLineDown : gui->doScroll(+1             ); return;
+	case CMD_emitSelection  : gui->insertSelection();         return;
+	case CMD_scrollPageUp   : gui->scroll(-gui->lines()/2); return;
+	case CMD_scrollPageDown : gui->scroll(+gui->lines()/2); return;
+	case CMD_scrollLineUp   : gui->scroll(-1             ); return;
+	case CMD_scrollLineDown : gui->scroll(+1             ); return;
 	case CMD_send           : sendString( txt );              return;
 	case CMD_prevSession    : emit prevSession();             return;
 	case CMD_nextSession    : emit nextSession();             return;
         }
     }
   // fall back handling
   if (!ev->text().isEmpty())
   {
     if (ev->state() & AltButton) sendString("\033"); // ESC, this is the ALT prefix
       /// very hacky
      if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='A')) sendString("\01");
      else if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='B')) sendString("\02");
      else if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='C')) sendString("\03");
      else if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='D')) sendString("\04");
      else if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='E')) sendString("\05");
      else if ((ev->state() & ControlButton) && (ev->text().upper().ascii()[0]=='F')) sendString("\06");
@@ -911,52 +911,52 @@ void Vt102Emulation::restoreCursor()
 
 void Vt102Emulation::resetModes()
 {
   resetMode(MODE_Mouse1000); saveMode(MODE_Mouse1000);
   resetMode(MODE_AppScreen); saveMode(MODE_AppScreen);
   // here come obsolete modes
   resetMode(MODE_AppCuKeys); saveMode(MODE_AppCuKeys);
   resetMode(MODE_NewLine  );
     setMode(MODE_Ansi     );
 }
 
 void Vt102Emulation::setMode(int m)
 {
   currParm.mode[m] = TRUE;
   switch (m)
   {
-    case MODE_Mouse1000 : gui->setMouseMarks(FALSE);
+    case MODE_Mouse1000 : //gui->setMouseMarks(FALSE);
     break;
     case MODE_AppScreen : screen[1]->clearSelection();
                           screen[1]->clearEntireScreen();
                           setScreen(1);
     break;
   }
   if (m < MODES_SCREEN || m == MODE_NewLine)
   {
     screen[0]->setMode(m);
     screen[1]->setMode(m);
   }
 }
 
 void Vt102Emulation::resetMode(int m)
 {
   currParm.mode[m] = FALSE;
   switch (m)
   {
-    case MODE_Mouse1000 : gui->setMouseMarks(TRUE);
+    case MODE_Mouse1000 : //gui->setMouseMarks(TRUE);
     break;
     case MODE_AppScreen : screen[0]->clearSelection();
                           setScreen(0);
     break;
   }
   if (m < MODES_SCREEN || m == MODE_NewLine)
   {
     screen[0]->resetMode(m);
     screen[1]->resetMode(m);
   }
 }
 
 void Vt102Emulation::saveMode(int m)
 {
   saveParm.mode[m] = currParm.mode[m];
 }
diff --git a/noncore/apps/opie-console/vt102emulation.h b/noncore/apps/opie-console/vt102emulation.h
index a3d0ae6..de4a62f 100644
--- a/noncore/apps/opie-console/vt102emulation.h
+++ b/noncore/apps/opie-console/vt102emulation.h
@@ -47,33 +47,33 @@ struct DECpar
 struct CharCodes
 {
   // coding info
   char charset[4]; //
   int  cu_cs;      // actual charset.
   bool graphic;    // Some VT100 tricks
   bool pound  ;    // Some VT100 tricks
   bool sa_graphic; // saved graphic
   bool sa_pound;   // saved pound
 };
 
 class Vt102Emulation: public EmulationLayer
 { Q_OBJECT
 
 public:
 
-  Vt102Emulation(Widget* gui);
+  Vt102Emulation(WidgetLayer* gui);
   ~Vt102Emulation();
 
 public slots: // signals incoming from Widget
  
   void onKeyPress(QKeyEvent*);
   void onMouse(int cb, int cx, int cy);
 
 signals:
 
   void changeTitle(int,const QString&);
   void prevSession();
   void nextSession();
 
 public:
 
   void reset();
diff --git a/noncore/apps/opie-console/widget_layer.h b/noncore/apps/opie-console/widget_layer.h
index 6e2e61e..5bd2ef9 100644
--- a/noncore/apps/opie-console/widget_layer.h
+++ b/noncore/apps/opie-console/widget_layer.h
@@ -93,32 +93,43 @@ public:
 	 * @param const QString &text, the text to be selected
 	 */
 	void setSelection( const QString &text );
 
 	/**
 	 * paste content of clipboard
 	 */
 	void pasteClipboard();
 
 
 	/**
 	 * reload configuration
 	 */
 	virtual void reloadConfig() = 0;
 
 
+	/**
+	 * sets the scrollbar (if implemented by successor of this class)
+	 */
+	virtual void setScroll( int cursor, int slines );
+
+	/**
+	 * scrolls (if implemented, by successor of this class)
+	 * @param int value, how much the widget should scroll up (positive value) or down (negative value)
+	 */
+	virtual void scroll( int value );
+		
 signals:
 
 	/**
 	 * key was pressed
 	 */
 	void keyPressed( QKeyEvent *e );
 
 	/**
 	 * whenever Mouse selects something
 	 * @param int button, the button that us pressed :
 	 * 		0	left Button
 	 * 		3	Button released
 	 * @param int x, x position
 	 * @param int y, y position
 	 *
 	 * // numbering due to layout in old TEWidget