no wrap mode taken from console, gui needs work

6 files changed, 491 insertions, 214 deletions

diff --git a/core/apps/embeddedkonsole/TEHistory.cpp b/core/apps/embeddedkonsole/TEHistory.cpp
index 317ce57..db9d10c 100644
--- a/core/apps/embeddedkonsole/TEHistory.cpp
+++ b/core/apps/embeddedkonsole/TEHistory.cpp
@@ -1,40 +1,40 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* [TEHistory.C]                   History Buffer                             */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* 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>                  */
-        /*                                                                    */
+/*                        */
 /* -------------------------------------------------------------------------- */
 
 #include "TEHistory.h"
 #include <stdlib.h>
 #include <assert.h>
 #include <stdio.h>
 #include <sys/types.h>
 #include <unistd.h>
 #include <errno.h>
 
 #define HERE printf("%s(%d): here\n",__FILE__,__LINE__)
 
 /*
    An arbitrary long scroll.
 
    One can modify the scroll only by adding either cells
    or newlines, but access it randomly.
 
    The model is that of an arbitrary wide typewriter scroll
    in that the scroll is a serie of lines and each line is
    a serie of cells with no overwriting permitted.
 
    The implementation provides arbitrary length and numbers
    of cells and line/column indexed read access to the scroll
@@ -96,60 +96,66 @@ void HistoryBuffer::setScroll(bool on)
   {
     assert( ion < 0 );
     assert( length == 0);
     FILE* tmp = tmpfile(); if (!tmp) { perror("konsole: cannot open temp file.\n"); return; }
     ion = dup(fileno(tmp)); if (ion<0) perror("konsole: cannot dup temp file.\n");
     fclose(tmp);
   }
   else
   {
     assert( ion >= 0 );
     close(ion);
     ion    = -1;
     length = 0;
   }
 }
 
 bool HistoryBuffer::hasScroll()
 {
   return ion >= 0;
 }
 
 void HistoryBuffer::add(const unsigned char* bytes, int len)
 { int rc;
   assert(hasScroll());
-  rc = lseek(ion,length,SEEK_SET); if (rc < 0) { perror("HistoryBuffer::add.seek"); setScroll(FALSE); return; }
-  rc = write(ion,bytes,len);       if (rc < 0) { perror("HistoryBuffer::add.write"); setScroll(FALSE); return; }
+  rc = lseek( ion, length, SEEK_SET);
+  if (rc < 0) { perror("HistoryBuffer::add.seek"); setScroll(FALSE); return; }
+  rc = write( ion, bytes, len);
+  if (rc < 0) { perror("HistoryBuffer::add.write"); setScroll(FALSE); return; }
   length += rc;
 }
 
-void HistoryBuffer::get(unsigned char* bytes, int len, int loc)
-{ int rc;
+void HistoryBuffer::get(unsigned char* bytes, int len, int loc) {
+    int rc;
   assert(hasScroll());
+//  qDebug("history get len %d, loc %d, length %d", len, loc, length);
   if (loc < 0 || len < 0 || loc + len > length)
-    fprintf(stderr,"getHist(...,%d,%d): invalid args.\n",len,loc);
-  rc = lseek(ion,loc,SEEK_SET); if (rc < 0) { perror("HistoryBuffer::get.seek"); setScroll(FALSE); return; }
-  rc = read(ion,bytes,len);     if (rc < 0) { perror("HistoryBuffer::get.read"); setScroll(FALSE); return; }
+     fprintf(stderr,"getHist(...,%d,%d): invalid args.\n",len,loc);
+     
+  rc = lseek( ion, loc, SEEK_SET);
+  if (rc < 0) { perror("HistoryBuffer::get.seek"); setScroll(FALSE); return; }
+  rc = read( ion, bytes, len);
+  if (rc < 0) { perror("HistoryBuffer::get.read"); setScroll(FALSE); return; }
 }
 
 int HistoryBuffer::len()
 {
   return length;
 }
 
 // History Scroll //////////////////////////////////////
 
 /* 
    The history scroll makes a Row(Row(Cell)) from
    two history buffers. The index buffer contains
    start of line positions which refere to the cells
    buffer.
 
    Note that index[0] addresses the second line
    (line #1), while the first line (line #0) starts
    at 0 in cells.
 */
 
 HistoryScroll::HistoryScroll()
 {
 }
 
@@ -174,39 +180,40 @@ int HistoryScroll::getLines()
   return index.len() / sizeof(int);
 }
 
 int HistoryScroll::getLineLen(int lineno)
 {
   if (!hasScroll()) return 0;
   return (startOfLine(lineno+1) - startOfLine(lineno)) / sizeof(ca);
 }
 
 int HistoryScroll::startOfLine(int lineno)
 {
   if (lineno <= 0) return 0;
   if (!hasScroll()) return 0;
   if (lineno <= getLines())
   { int res;
     index.get((unsigned char*)&res,sizeof(int),(lineno-1)*sizeof(int));
     return res;
   }
   return cells.len();
 }
 
 void HistoryScroll::getCells(int lineno, int colno, int count, ca res[])
 {
   assert(hasScroll());
-  cells.get((unsigned char*)res,count*sizeof(ca),startOfLine(lineno)+colno*sizeof(ca));
+//get(unsigned char* bytes, int len, int loc)   
+  cells.get( (unsigned char*)res, count * sizeof(ca), startOfLine( lineno) + colno * sizeof(ca) );
 }
 
 void HistoryScroll::addCells(ca text[], int count)
 {
   if (!hasScroll()) return;
   cells.add((unsigned char*)text,count*sizeof(ca));
 }
 
 void HistoryScroll::addLine()
 {
   if (!hasScroll()) return;
   int locn = cells.len();
   index.add((unsigned char*)&locn,sizeof(int));
 }
diff --git a/core/apps/embeddedkonsole/TEScreen.cpp b/core/apps/embeddedkonsole/TEScreen.cpp
index a3d115d..50807d3 100644
--- a/core/apps/embeddedkonsole/TEScreen.cpp
+++ b/core/apps/embeddedkonsole/TEScreen.cpp
@@ -1,98 +1,102 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* [TEScreen.C]               Screen Data Type                                */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* 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>                  */
-        /*                                                                    */
+/*                        */
 /* -------------------------------------------------------------------------- */
+// enhancements added by L.J. Potter <ljp@llornkcor.com>
 
 /*! \file
 */
 
 /*! \class TEScreen
 
     \brief The image manipulated by the emulation.
 
     This class implements the operations of the terminal emulation framework.
     It is a complete passive device, driven by the emulation decoder
     (TEmuVT102). By this it forms in fact an ADT, that defines operations
     on a rectangular image.
 
     It does neither know how to display its image nor about escape sequences.
     It is further independent of the underlying toolkit. By this, one can even
     use this module for an ordinary text surface.
 
     Since the operations are called by a specific emulation decoder, one may
     collect their different operations here.
 
     The state manipulated by the operations is mainly kept in `image', though
     it is a little more complex bejond this. See the header file of the class.
 
     \sa TEWidget \sa VT102Emulation
 */
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 // #include <kdebug.h>
 
 #include <assert.h>
 #include <string.h>
 #include <ctype.h>
 
+#include <qpe/config.h>
 #include "TEScreen.h"
 
 #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))
+#define loc(X,Y) ((Y) * columns + (X))
 
 /*! creates a `TEScreen' of `lines' lines and `columns' columns.
 */
 
 TEScreen::TEScreen(int lines, int columns)
 {
   this->lines   = lines;
   this->columns = columns;
-
+//  qDebug("Columns %d", columns);
+  
   image      = (ca*) malloc(lines*columns*sizeof(ca));
   tabstops   = NULL; initTabStops();
 
   histCursor = 0;
+  horzCursor = 0;
 
   clearSelection();
   reset();
 }
 
 /*! Destructor
 */
 
 TEScreen::~TEScreen()
 {
   free(image);
   if (tabstops) free(tabstops);
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /* Normalized                    Screen Operations                           */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 // Cursor Setting --------------------------------------------------------------
 
 /*! \section Cursor
 
@@ -362,95 +366,91 @@ void TEScreen::restoreCursor()
   cu_re   = sa_cu_re;
   cu_fg   = sa_cu_fg;
   cu_bg   = sa_cu_bg;
   effectiveRendition();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                             Screen Operations                             */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /*! Assing a new size to the screen.
 
     The topmost left position is maintained, while lower lines
     or right hand side columns might be removed or filled with
     spaces to fit the new size.
 
     The region setting is reset to the whole screen and the
     tab positions reinitialized.
 */
 
 void TEScreen::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);
+    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(horzCursor,1);
+        }
     }
-  }
 
-  // make new image
-  ca* newimg = (ca*)malloc(new_lines*new_columns*sizeof(ca));
+      // make new image
+    ca* newimg = (ca*)malloc( new_lines * new_columns * sizeof( ca));
 
-  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);
-  image = newimg;
-  lines = new_lines;
-  columns = new_columns;
-  cuX = QMIN(cuX,columns-1);
-  cuY = QMIN(cuY,lines-1);
+    clearSelection();
 
-  // FIXME: try to keep values, evtl.
-  tmargin=0;
-  bmargin=lines-1;
-  initTabStops();
-  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);
+    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.
 
    currently, TEWidget's color table is
      0       1       2 .. 9    10 .. 17
      dft_fg, dft_bg, dim 0..7, intensive 0..7
 
    cu_fg, cu_bg contain values 0..8;
    - 0    = default color
    - 1..8 = ansi specified color
 
    re_fg, re_bg contain values 0..17
    due to the TEWidget's color table
 
    rendition attributes are
 
       attr           widget screen
       -------------- ------ ------
       RE_UNDERLINE     XX     XX    affects foreground only
       RE_BLINK         XX     XX    affects foreground only
       RE_BOLD          XX     XX    affects foreground only
       RE_REVERSE       --     XX
@@ -484,100 +484,165 @@ void TEScreen::effectiveRendition()
   {
     ef_fg = cu_fg;
     ef_bg = cu_bg;
   }
   if (cu_re & RE_BOLD)
   {
     if (ef_fg < BASE_COLORS)
       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.
 
 */
 
 ca* TEScreen::getCookedImage()
-{ int x,y;
+{
+ int x,y;
   ca* merged = (ca*)malloc(lines*columns*sizeof(ca));
   ca 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
     }
   }
   if (lines >= hist.getLines()-histCursor)
   {
     for (y = (hist.getLines()-histCursor); y < lines ; y++)
     {
        int yp  = y*columns;
        int yq  = (y+histCursor)*columns;
        int yr =  (y-hist.getLines()+histCursor)*columns;
        for (x = 0; x < columns; x++)
        { 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;
+
+    /*
+    int x, y, z;
+
+  ca* merged = (ca*)malloc( lines * columns * sizeof( ca));
+
+  ca dft(' ',DEFAULT_FORE_COLOR,DEFAULT_BACK_COLOR,DEFAULT_RENDITION);
+
+//      qDebug("hist lines %d, historyCursor %d, minus %d ,lines %d, columns %d",
+//               hist.getLines(), histCursor, hist.getLines() - histCursor , lines, columns);
+  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;
+//     qDebug("horzCursor %d, columns %d, len %d", horzCursor, columns, len);    
+//     qDebug("lineno %d, colno %d, count %d\n",  y + histCursor, (horzCursor / 2), len );
+    qDebug("Y %d", y);    
+    hist.getCells( y + histCursor, (horzCursor / 2), 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
+    }
+  }
+
+  if (lines >= hist.getLines() - histCursor)  {
+      for (y = ( hist.getLines() - histCursor); y < lines ; y++)  {
+       int z = horzCursor;
+       int yp  = y * columns;
+       int yq  = ( y + histCursor) * columns;
+       int yr =  ( y - hist.getLines() + histCursor) * columns;
+//        qDebug("y %d, yp %d, yq %d, columns %d, z cursor %d", y,  yp, yq, columns, z);
+       for (x = 0; x < columns; x++) {
+           int p = x + yp; int q = x + yq; int r = (x + (horzCursor/2) ) + 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;
+      */
+  
 }
 
 
 /*!
 */
 
 void TEScreen::reset()
 {
+  Config cfg("Konsole");
+  cfg.setGroup("ScrollBar");
+  if( !cfg.readBoolEntry("HorzScroll",0) )
     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;
   bmargin=lines-1;
 
   setDefaultRendition();
   saveCursor();
 
   clear();
 }
 
 /*! Clear the entire screen and home the cursor.
 */
 
 void TEScreen::clear()
 {
   clearEntireScreen();
   home();
 }
 
@@ -637,96 +702,102 @@ void TEScreen::NewLine()
     VT100 uses the convention to produce an automatic newline (am)
     with the *first* character that would fall onto the next line (xenl).
 */
 
 void TEScreen::checkSelection(int from, int to)
 {
   if (sel_begin == -1) return;
   int scr_TL = loc(0, hist.getLines());
   //Clear entire selection if it overlaps region [from, to]
   if ( (sel_BR > (from+scr_TL) )&&(sel_TL < (to+scr_TL)) )
   {
     clearSelection();
   }
 }
 
 void TEScreen::ShowCharacter(unsigned short c)
 {
   // Note that VT100 does wrapping BEFORE putting the character.
   // This has impact on the assumption of valid cursor positions.
   // We indicate the fact that a newline has to be triggered by
   // putting the cursor one right to the last column of the screen.
 
   if (cuX >= columns)
   {
-    if (getMode(MODE_Wrap)) NextLine(); else cuX = columns-1;
+    if (getMode(MODE_Wrap)) NextLine(); else cuX = columns - 1;
+       // comment out for no wrap
   }
 
   if (getMode(MODE_Insert)) insertChars(1);
 
-  int i = loc(cuX,cuY);
+  int i = loc( cuX, cuY);
 
   checkSelection(i, i); // check if selection is still valid.
 
   image[i].c = c;
   image[i].f = ef_fg;
   image[i].b = ef_bg;
   image[i].r = ef_re;
 
   cuX += 1;
 }
 
 // Region commands -------------------------------------------------------------
 
 
 /*! scroll up `n' lines within current region.
     The `n' new lines are cleared.
     \sa setRegion \sa scrollDown
 */
 
 void TEScreen::scrollUp(int from, int n)
 {
-  if (n <= 0 || from + n > bmargin) return;
+ if (n <= 0 || from + n > bmargin) return;
   //FIXME: make sure `tmargin', `bmargin', `from', `n' is in bounds.
-  moveImage(loc(0,from),loc(0,from+n),loc(columns-1,bmargin));
-  clearImage(loc(0,bmargin-n+1),loc(columns-1,bmargin),' ');
+
+    moveImage( loc( 0, from), loc( 0, from + n), loc( columns - 1, bmargin));
+    clearImage( loc( 0, bmargin - n + 1), loc( columns - 1, bmargin), ' ');
 }
 
 /*! scroll down `n' lines within current region.
     The `n' new lines are cleared.
     \sa setRegion \sa scrollUp
 */
 
 void TEScreen::scrollDown(int from, int n)
 {
+    
 //FIXME: make sure `tmargin', `bmargin', `from', `n' is in bounds.
-  if (n <= 0) return;
+ if (n <= 0) return;
   if (from > bmargin) return;
   if (from + n > bmargin) n = bmargin - from;
-  moveImage(loc(0,from+n),loc(0,from),loc(columns-1,bmargin-n));
+
+  moveImage( loc(0,from+n), loc(0,from), loc(columns-1,bmargin-n));
   clearImage(loc(0,from),loc(columns-1,from+n-1),' ');
 }
 
+
+
 /*! position the cursor to a specific line and column. */
 void TEScreen::setCursorYX(int y, int x)
 {
   setCursorY(y); setCursorX(x);
 }
 
 /*! Set the cursor to x-th line. */
 
 void TEScreen::setCursorX(int x)
 {
   if (x == 0) x = 1; // Default
   x -= 1; // Adjust
   cuX = QMAX(0,QMIN(columns-1, x));
 }
 
 /*! Set the cursor to y-th line. */
 
 void TEScreen::setCursorY(int y)
 {
   if (y == 0) y = 1; // Default
   y -= 1; // Adjust
   cuY = QMAX(0,QMIN(lines  -1, y + (getMode(MODE_Origin) ? tmargin : 0) ));
 }
 
@@ -850,49 +921,49 @@ void TEScreen::helpAlign()
   clearImage(loc(0,0),loc(columns-1,lines-1),'E');
 }
 
 /*! clear from (including) current cursor position to end of current cursor line.
 */
 
 void TEScreen::clearToEndOfLine()
 {
   clearImage(loc(cuX,cuY),loc(columns-1,cuY),' ');
 }
 
 /*! clear from begin of current cursor line to (including) current cursor position.
 */
 
 void TEScreen::clearToBeginOfLine()
 {
   clearImage(loc(0,cuY),loc(cuX,cuY),' ');
 }
 
 /*! clears entire current cursor line
 */
 
 void TEScreen::clearEntireLine()
 {
-  clearImage(loc(0,cuY),loc(columns-1,cuY),' ');
+  clearImage( loc( 0, cuY),loc( columns - 1, cuY),' ');
 }
 
 // Rendition ------------------------------------------------------------------
 
 /*!
     set rendition mode
 */
 
 void TEScreen::setRendition(int re)
 {
   cu_re |= re;
   effectiveRendition();
 }
 
 /*!
     reset rendition mode
 */
 
 void TEScreen::resetRendition(int re)
 {
   cu_re &= ~re;
   effectiveRendition();
 }
 
@@ -967,231 +1038,241 @@ void TEScreen::setSelExtentXY(const int x, const int y)
 {
   if (sel_begin == -1) return;
   int l =  loc(x,y + histCursor);
 
   if (l < sel_begin)
   {
     sel_TL = l;
     sel_BR = sel_begin;
   }
   else
   {
     /* FIXME, HACK to correct for x too far to the right... */
     if (( x == columns )|| (x == 0)) l--;
 
     sel_TL = sel_begin;
     sel_BR = l;
   }
 }
 
 QString TEScreen::getSelText(const BOOL preserve_line_breaks)
 {
   if (sel_begin == -1) 
      return QString::null; // Selection got clear while selecting.
 
-          int *m;               // buffer to fill.
-          int s, d;             // source index, dest. index.
+  int *m;     // buffer to fill.
+  int s, d;     // source index, dest. index.
   int hist_BR = loc(0, hist.getLines());
   int hY = sel_TL / columns;
   int hX = sel_TL % columns;
-          int eol;              // end of line
+  int eol;      // end of line
 
-          s = sel_TL;           // tracks copy in source.
+  s = sel_TL;     // tracks copy in source.
 
-                                // allocate buffer for maximum
-                                // possible size...
+        // allocate buffer for maximum
+        // possible size...
   d = (sel_BR - sel_TL) / columns + 1;
   m = new int[d * (columns + 1) + 2];
   d = 0;
 
   while (s <= sel_BR)
     {
       if (s < hist_BR)
-                {               // get lines from hist.history
-                                // buffer.
-          eol = hist.getLineLen(hY);
-
-          if ((hY == (sel_BR / columns)) &&
-              (eol >= (sel_BR % columns)))
-            {
-              eol = sel_BR % columns + 1;
-            }
-          
-          while (hX < eol)
-            {
-              m[d++] = hist.getCell(hY, hX++).c;
-              s++;
-            }
-
-          if (s <= sel_BR)
-            {
-                                // The line break handling
-                                // It's different from the screen
-                                // image case!
-              if (eol % columns == 0)
-                {
-                                // That's either a completely filled
-                                // line or an empty line
-                  if (eol == 0)
-                    {
-                      m[d++] = '\n';
-                    }
-                  else
-                    {
-                                // We have a full line.
-                                // FIXME: How can we handle newlines
-                                // at this position?!
-                    }
-                }
-              else if ((eol + 1) % columns == 0)
-                {
-                                // FIXME: We don't know if this was a
-                                // space at the last position or a
-                                // short line!!
-                  m[d++] = ' ';
-                }
-              else
-                {
-                                // We have a short line here. Put a
-                                // newline or a space into the
-                                // buffer.
-                  m[d++] = preserve_line_breaks ? '\n' : ' ';
-                }
-            }
-
-          hY++;
-          hX = 0;
-          s = hY * columns;
-        }
+  {     // get lines from hist.history
+        // buffer.
+    eol = hist.getLineLen(hY);
+
+    if ((hY == (sel_BR / columns)) &&
+        (eol >= (sel_BR % columns)))
+      {
+        eol = sel_BR % columns + 1;
+      }
+    
+    while (hX < eol)
+      {
+        m[d++] = hist.getCell(hY, hX++).c;
+        s++;
+      }
+
+    if (s <= sel_BR)
+      {
+        // The line break handling
+        // It's different from the screen
+        // image case!
+        if (eol % columns == 0)
+    {
+        // That's either a completely filled
+        // line or an empty line
+      if (eol == 0)
+        {
+          m[d++] = '\n';
+        }
+      else
+        {
+        // We have a full line.
+        // FIXME: How can we handle newlines
+        // at this position?!
+        }
+    }
+        else if ((eol + 1) % columns == 0)
+    {
+        // FIXME: We don't know if this was a
+        // space at the last position or a
+        // short line!!
+      m[d++] = ' ';
+    }
+        else
+    {
+        // We have a short line here. Put a
+        // newline or a space into the
+        // buffer.
+      m[d++] = preserve_line_breaks ? '\n' : ' ';
+    }
+      }
+
+    hY++;
+    hX = 0;
+    s = hY * columns;
+  }
     else
-              {                         // or from screen image.
-        eol = (s / columns + 1) * columns - 1;
-
-        if (eol < sel_BR)
-          {
-            while ((eol > s) &&
-                   isspace(image[eol - hist_BR].c))
-              {
-                eol--;
-              }
-          }
-        else
-          {
-            eol = sel_BR;
-          }
-
-        while (s <= eol)
-          {
-            m[d++] = image[s++ - hist_BR].c;
-          }
-
-        if (eol < sel_BR)
-          {
-                                // eol processing see below ...
-            if ((eol + 1) % columns == 0)
-              {
-                if (image[eol - hist_BR].c == ' ')
-                  {
-                    m[d++] = ' ';
-                  }
-              }
-            else
-              {
-                m[d++] = ((preserve_line_breaks ||
-                           ((eol % columns) == 0)) ?
-                          '\n' : ' ');
-              }
-          }
-
-        s = (eol / columns + 1) * columns;
+      {       // or from screen image.
+  eol = (s / columns + 1) * columns - 1;
+
+  if (eol < sel_BR)
+    {
+      while ((eol > s) &&
+       isspace(image[eol - hist_BR].c))
+        {
+    eol--;
+        }
+    }
+  else
+    {
+      eol = sel_BR;
+    }
+
+  while (s <= eol)
+    {
+      m[d++] = image[s++ - hist_BR].c;
+    }
+
+  if (eol < sel_BR)
+    {
+        // eol processing see below ...
+      if ((eol + 1) % columns == 0)
+        {
+    if (image[eol - hist_BR].c == ' ')
+      {
+        m[d++] = ' ';
+      }
+        }
+      else
+        {
+    m[d++] = ((preserve_line_breaks ||
+         ((eol % columns) == 0)) ?
+        '\n' : ' ');
+        }
+    }
+
+  s = (eol / columns + 1) * columns;
       }
     }
 
   QChar* qc = new QChar[d];
 
   for (int i = 0; i < d; i++)
     {
       qc[i] = m[i];
     }
   
   QString res(qc, d);
 
   delete m;
   delete qc;
 
   return res;
 }
 /* above ... end of line processing for selection -- psilva
 cases:
 
 1)    (eol+1)%columns == 0 --> the whole line is filled.
    If the last char is a space, insert (preserve) space. otherwise
    leave the text alone, so that words that are broken by linewrap
    are preserved.
 
 FIXME:
-        * this suppresses \n for command output that is
-          sized to the exact column width of the screen.
+  * this suppresses \n for command output that is
+    sized to the exact column width of the screen.
 
 2)    eol%columns == 0     --> blank line.
    insert a \n unconditionally.
    Do it either you would because you are in preserve_line_break mode,
    or because it's an ASCII paragraph delimiter, so even when
    not preserving line_breaks, you want to preserve paragraph breaks.
 
-        3)    else       --> partially filled line
+3)    else     --> partially filled line
    insert a \n in preserve line break mode, else a space
    The space prevents concatenation of the last word of one
    line with the first of the next.
 
 */
 
 void TEScreen::addHistLine()
 {
   assert(hasScroll() || histCursor == 0);
 
   // add to hist buffer
   // we have to take care about scrolling, too...
 
-  if (hasScroll())
-  { ca dft;
+  if (hasScroll()){
+      ca dft;
 
-    int end = columns-1;
+    int end = columns - 1;
     while (end >= 0 && image[end] == dft)
       end -= 1;
 
-    hist.addCells(image,end+1);
+    hist.addCells( image, end + 1);
     hist.addLine();
 
     // adjust history cursor
-    histCursor += (hist.getLines()-1 == histCursor);
+    histCursor += ( hist.getLines() - 1 == histCursor);
   }
 
   if (!hasScroll()) histCursor = 0; //FIXME: a poor workaround
 }
 
 void TEScreen::setHistCursor(int cursor)
 {
   histCursor = cursor; //FIXME:rangecheck
 }
 
+void TEScreen::setHorzCursor(int cursor)
+{
+  horzCursor = cursor; 
+}
+
 int TEScreen::getHistCursor()
 {
   return histCursor;
 }
 
+int TEScreen::getHorzCursor()
+{
+  return horzCursor;
+}
+
 int TEScreen::getHistLines()
 {
   return hist.getLines();
 }
 
 void TEScreen::setScroll(bool on)
 {
   histCursor = 0;
   clearSelection();
   hist.setScroll(on);
 }
 
 bool TEScreen::hasScroll()
 {
   return hist.hasScroll();
 }
diff --git a/core/apps/embeddedkonsole/TEWidget.cpp b/core/apps/embeddedkonsole/TEWidget.cpp
index b1ad008..c10c7a8 100644
--- a/core/apps/embeddedkonsole/TEWidget.cpp
+++ b/core/apps/embeddedkonsole/TEWidget.cpp
@@ -31,48 +31,55 @@
    <li> (internally) the external image is simply copied to the internal
         when a setImage happens. During a resizeEvent no painting is done
         a paintEvent is expected to follow anyway.
    </ul>
 
    \sa TEScreen \sa Emulation
 */
 
 /* FIXME:
    - 'image' may also be used uninitialized (it isn't in fact) in resizeEvent
    - 'font_a' not used in mouse events
    - add destructor
 */
 
 /* TODO
    - evtl. be sensitive to `paletteChange' while using default colors.
    - set different 'rounding' styles? I.e. have a mode to show clipped chars?
 */
 
 // #include "config.h"
 #include "TEWidget.h"
 #include "session.h"
 #include <qpe/config.h>
 
+#include <qpe/resource.h>
+#include <qpe/sound.h>
+
+#ifdef QWS
+#include <qpe/qcopenvelope_qws.h>
+#endif
+
 #include <qcursor.h>
 #include <qregexp.h>
 #include <qpainter.h>
 #include <qclipboard.h>
 #include <qstyle.h>
 #include <qfile.h>
 #include <qdragobject.h>
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <ctype.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <signal.h>
 
 #include <assert.h>
 
 // #include "TEWidget.moc"
 //#include <kapp.h>
 //#include <kcursor.h>
 //#include <kurl.h>
 //#include <kdebug.h>
 //#include <klocale.h>
@@ -266,76 +273,86 @@ QFont TEWidget::getVTFont() {
 
 void TEWidget::setFont(const QFont &)
 {
   // ignore font change request if not coming from konsole itself
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                         Constructor / Destructor                          */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 TEWidget::TEWidget(QWidget *parent, const char *name) : QFrame(parent,name)
 {
 #ifndef QT_NO_CLIPBOARD
   cb = QApplication::clipboard();
   QObject::connect( (QObject*)cb, SIGNAL(dataChanged()),
                     this, SLOT(onClearSelection()) );
 #endif
 
   scrollbar = new QScrollBar(this);
   scrollbar->setCursor( arrowCursor );
   connect(scrollbar, SIGNAL(valueChanged(int)), this, SLOT(scrollChanged(int)));
 
+  hScrollbar = new QScrollBar(this);
+  hScrollbar->setCursor( arrowCursor );
+  hScrollbar->setOrientation(QScrollBar::Horizontal);
+  hScrollbar->setMaximumHeight(16);
+  
+  connect( hScrollbar, SIGNAL(valueChanged(int)), this, SLOT( hScrollChanged(int)));
+
   Config cfg("Konsole");
   cfg.setGroup("ScrollBar");
   switch( cfg.readNumEntry("Position",2)){
   case 0:
       scrollLoc = SCRNONE;
       break;
   case 1:
       scrollLoc = SCRLEFT;
       break;
   case 2:
       scrollLoc = SCRRIGHT;
       break;
   };
 
+  useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
+
   blinkT   = new QTimer(this);
   connect(blinkT, SIGNAL(timeout()), this, SLOT(blinkEvent()));
   // blinking = FALSE;
   blinking = TRUE;
 
   resizing = FALSE;
   actSel   = 0;
   image    = 0;
   lines    = 1;
   columns  = 1;
   font_w   = 1;
   font_h   = 1;
   font_a   = 1;
   word_selection_mode = FALSE;
+  hposition = 0;
 
   setMouseMarks(TRUE);
   setVTFont( QFont("fixed") );
   setColorTable(base_color_table); // init color table
 
   qApp->installEventFilter( this ); //FIXME: see below
 //  KCursor::setAutoHideCursor( this, true );
 
   // Init DnD ////////////////////////////////////////////////////////////////
   currentSession = NULL;
 //  setAcceptDrops(true); // attempt
 //  m_drop = new QPopupMenu(this);
 //  m_drop->insertItem( QString("Paste"), 0);
 //  m_drop->insertItem( QString("cd"),    1);
 //  connect(m_drop, SIGNAL(activated(int)), SLOT(drop_menu_activated(int)));
 
   // we need focus so that the auto-hide cursor feature works
   setFocus();
   setFocusPolicy( WheelFocus );
 }
 
 //FIXME: make proper destructor
 // Here's a start (David)
 TEWidget::~TEWidget()
@@ -389,52 +406,49 @@ void TEWidget::drawAttrStr(QPainter &paint, QRect rect,
 
     The size of the new image may or may not match the size of the widget.
 */
 
 void TEWidget::setImage(const ca* const newimg, int lines, int columns)
 { int y,x,len;
   const QPixmap* pm = backgroundPixmap();
   QPainter paint;
   setUpdatesEnabled(FALSE);
   paint.begin( this );
 HCNT("setImage");
 
   QPoint tL  = contentsRect().topLeft();
   int    tLx = tL.x();
   int    tLy = tL.y();
   hasBlinker = FALSE;
 
   int cf  = -1; // undefined
   int cb  = -1; // undefined
   int cr  = -1; // undefined
 
   int lins = QMIN(this->lines,  QMAX(0,lines  ));
   int cols = QMIN(this->columns,QMAX(0,columns));
   QChar *disstrU = new QChar[cols];
-
-//{ static int cnt = 0; printf("setImage %d\n",cnt++); }
-  for (y = 0; y < lins; y++)
-  {
+  for (y = 0; y < lins; y++) {
     const ca*       lcl = &image[y*this->columns];
     const ca* const ext = &newimg[y*columns];
     if (!resizing) // not while resizing, we're expecting a paintEvent
     for (x = 0; x < cols; x++)
     {
       hasBlinker |= (ext[x].r & RE_BLINK);
       if (ext[x] != lcl[x])
       {
         cr = ext[x].r;
         cb = ext[x].b;
         if (ext[x].f != cf) cf = ext[x].f;
         int lln = cols - x;
         disstrU[0] = fontMap(ext[x+0].c);
         for (len = 1; len < lln; len++)
         {
           if (ext[x+len].f != cf || ext[x+len].b != cb || ext[x+len].r != cr ||
               ext[x+len] == lcl[x+len] )
             break;
           disstrU[len] = fontMap(ext[x+len].c);
         }
         QString unistr(disstrU,len);
         drawAttrStr(paint,
                     QRect(blX+tLx+font_w*x,bY+tLy+font_h*y,font_w*len,font_h),
                     unistr, ext[x], pm != NULL, true);
@@ -567,53 +581,60 @@ void TEWidget::propagateSize()
   if (oldimg)
   {
     for (int lin = 0; lin < lins; lin++)
       memcpy((void*)&image[columns*lin],
              (void*)&oldimg[oldcol*lin],cols*sizeof(ca));
     free(oldimg); //FIXME: try new,delete
   }
   else
     clearImage();
 
   //NOTE: control flows from the back through the chest right into the eye.
   //      `emu' will call back via `setImage'.
 
   resizing = TRUE;
   emit changedImageSizeSignal(lines, columns); // expose resizeEvent
   resizing = FALSE;
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                Scrollbar                                  */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
-void TEWidget::scrollChanged(int)
-{
+void TEWidget::scrollChanged(int) {
   emit changedHistoryCursor(scrollbar->value()); //expose
 }
 
+void TEWidget::hScrollChanged(int loc) {
+  hposition = loc;
+  propagateSize();
+  update();
+
+//  emit changedHorzCursor( hScrollbar->value()); //expose
+}
+
 void TEWidget::setScroll(int cursor, int slines)
 {
   disconnect(scrollbar, SIGNAL(valueChanged(int)), this, SLOT(scrollChanged(int)));
   scrollbar->setRange(0,slines);
   scrollbar->setSteps(1,lines);
   scrollbar->setValue(cursor);
   connect(scrollbar, SIGNAL(valueChanged(int)), this, SLOT(scrollChanged(int)));
 }
 
 void TEWidget::setScrollbarLocation(int loc)
 {
   if (scrollLoc == loc) return; // quickly
   scrollLoc = loc;
   propagateSize();
   update();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Mouse                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 /*!
@@ -676,48 +697,49 @@ void TEWidget::mousePressEvent(QMouseEvent* ev)
   {
     emitSelection();
   }
   if ( ev->button() == RightButton ) // Configure
   {
     emit configureRequest( this, ev->state()&(ShiftButton|ControlButton), ev->x(), ev->y() );
   }
 }
 
 void TEWidget::mouseMoveEvent(QMouseEvent* ev)
 {
   // for auto-hiding the cursor, we need mouseTracking
   if (ev->state() == NoButton ) return;
 
   if (actSel == 0) return;
 
  // don't extend selection while pasting
   if (ev->state() & MidButton) return;
 
   //if ( !contentsRect().contains(ev->pos()) ) return;
   QPoint tL  = contentsRect().topLeft();
   int    tLx = tL.x();
   int    tLy = tL.y();
   int    scroll = scrollbar->value();
+//  int    hScroll = hScrollbar->value();
 
   // we're in the process of moving the mouse with the left button pressed
   // the mouse cursor will kept catched within the bounds of the text in
   // this widget.
 
   // Adjust position within text area bounds. See FIXME above.
   QPoint pos = ev->pos();
   if ( pos.x() < tLx+blX )                  pos.setX( tLx+blX );
   if ( pos.x() > tLx+blX+columns*font_w-1 ) pos.setX( tLx+blX+columns*font_w );
   if ( pos.y() < tLy+bY )                   pos.setY( tLy+bY );
   if ( pos.y() > tLy+bY+lines*font_h-1 )    pos.setY( tLy+bY+lines*font_h-1 );
   // check if we produce a mouse move event by this
   if ( pos != ev->pos() ) cursor().setPos(mapToGlobal(pos));
 
   if ( pos.y() == tLy+bY+lines*font_h-1 )
   {
     scrollbar->setValue(scrollbar->value()+yMouseScroll); // scrollforward
   }
   if ( pos.y() == tLy+bY )
   {
     scrollbar->setValue(scrollbar->value()-yMouseScroll); // scrollback
   }
 
   QPoint here = QPoint((pos.x()-tLx-blX)/font_w,(pos.y()-tLy-bY)/font_h);
@@ -952,48 +974,52 @@ void TEWidget::onClearSelection()
 /*                                                                           */
 /*                                Keyboard                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 //FIXME: an `eventFilter' has been installed instead of a `keyPressEvent'
 //       due to a bug in `QT' or the ignorance of the author to prevent
 //       repaint events being emitted to the screen whenever one leaves
 //       or reenters the screen to/from another application.
 //
 //   Troll says one needs to change focusInEvent() and focusOutEvent(),
 //   which would also let you have an in-focus cursor and an out-focus
 //   cursor like xterm does.
 
 // for the auto-hide cursor feature, I added empty focusInEvent() and
 // focusOutEvent() so that update() isn't called.
 // For auto-hide, we need to get keypress-events, but we only get them when
 // we have focus.
 
 void TEWidget::doScroll(int lines)
 {
   scrollbar->setValue(scrollbar->value()+lines);
 }
 
+void TEWidget::doHScroll(int lines) {
+  hScrollbar->setValue( hScrollbar->value()+lines);
+}
+
 bool TEWidget::eventFilter( QObject *obj, QEvent *e )
 {
     if ( (e->type() == QEvent::Accel ||
           e->type() == QEvent::AccelAvailable ) && qApp->focusWidget() == this )  {
         static_cast<QKeyEvent *>( e )->ignore();
         return true;
     }
     if ( obj != this /* when embedded */ && obj != parent() /* when standalone */ )
         return FALSE; // not us
     if ( e->type() == QEvent::Wheel)  {
         QApplication::sendEvent(scrollbar, e);
     }
 
 #ifdef FAKE_CTRL_AND_ALT
     static bool control = FALSE;
     static bool alt = FALSE;
 //    qDebug(" Has a keyboard with no CTRL and ALT keys, but we fake it:");
     bool dele=FALSE;
     if ( e->type() == QEvent::KeyPress || e->type() == QEvent::KeyRelease ) {
         QKeyEvent* ke = (QKeyEvent*)e;
         bool keydown = e->type() == QEvent::KeyPress || ke->isAutoRepeat();
         switch (ke->key()) {
           case Key_F9: // let this be "Control"
               control = keydown;
@@ -1057,105 +1083,210 @@ bool TEWidget::eventFilter( QObject *obj, QEvent *e )
     }
     return QFrame::eventFilter( obj, e );
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                  Frame                                    */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TEWidget::frameChanged()
 {
   propagateSize();
   update();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                   Sound                                   */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TEWidget::Bell()
 {
-  QApplication::beep();
+//#ifdef QT_QWS_CUSTOM
+//# ifndef QT_NO_COP
+    QCopEnvelope( "QPE/TaskBar", "soundAlarm()" );
+//# endif
+//#else
+//# ifndef QT_NO_SOUND
+//    QSound::play(Resource::findSound("alarm"));
+//# endif
+//#endif    
+
+//    QApplication::beep();
 }
 
 /* ------------------------------------------------------------------------- */
 /*                                                                           */
 /*                                 Auxiluary                                 */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 void TEWidget::clearImage()
 // initialize the image
 // for internal use only
 {
   for (int y = 0; y < lines; y++)
   for (int x = 0; x < columns; x++)
   {
     image[loc(x,y)].c = 0xff; //' ';
     image[loc(x,y)].f = 0xff; //DEFAULT_FORE_COLOR;
     image[loc(x,y)].b = 0xff; //DEFAULT_BACK_COLOR;
     image[loc(x,y)].r = 0xff; //DEFAULT_RENDITION;
   }
 }
 
 // Create Image ///////////////////////////////////////////////////////
 
 void TEWidget::calcGeometry()
 {
-  //FIXME: set rimX == rimY == 0 when running in full screen mode.
+    int showhscrollbar = 1;
+    int hwidth = 0;
+    int dcolumns;
+    Config cfg("Konsole");
+    cfg.setGroup("ScrollBar");
+    useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
+
+    if(vcolumns == 0) showhscrollbar = 0;
+    if(showhscrollbar == 1) hwidth = QApplication::style().scrollBarExtent().width();
+
+    scrollbar->resize(QApplication::style().scrollBarExtent().width(),
+                      contentsRect().height() - hwidth);
+
+    switch(scrollLoc)  {
+      case SCRNONE :
+          columns = ( contentsRect().width() - 2 * rimX ) / font_w;
+          dcolumns = columns;
+          if(vcolumns) columns = vcolumns;
+          blX = (contentsRect().width() - (columns*font_w) ) / 2;
+          if(showhscrollbar)
+              blX = -hposition * font_w;
+          brX = blX;
+          scrollbar->hide();
+          break;
+      case SCRLEFT :
+          columns = ( contentsRect().width() - 2 * rimX - scrollbar->width()) / font_w;
+          dcolumns = columns;
+          if(vcolumns) columns = vcolumns;
+          brX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
+          if(showhscrollbar)
+              brX = -hposition * font_w;
+          blX = brX + scrollbar->width();
+          scrollbar->move(contentsRect().topLeft());
+          scrollbar->show();
+          break;
+      case SCRRIGHT:
+          columns = ( contentsRect().width()  - 2 * rimX - scrollbar->width()) / font_w;
+          dcolumns = columns;
+          if(vcolumns) columns = vcolumns;
+          blX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
+          if(showhscrollbar)
+              blX = -hposition * font_w;
+          brX = blX;
+          scrollbar->move(contentsRect().topRight() - QPoint(scrollbar->width()-1,0));
+          scrollbar->show();
+          break;
+    }
+      //FIXME: support 'rounding' styles
+    lines   = ( contentsRect().height() - 2 * rimY  ) / font_h;
+    bY = (contentsRect().height() - (lines  *font_h)) / 2;
 
-  scrollbar->resize(QApplication::style().scrollBarExtent().width(),
+    if(showhscrollbar == 1)  {
+        hScrollbar->resize(contentsRect().width() - hwidth, hwidth);
+        hScrollbar->setRange(0, vcolumns - dcolumns);
+
+        QPoint p = contentsRect().bottomLeft();
+        hScrollbar->move(QPoint(p.x(), p.y() - hwidth));
+        hScrollbar->show();
+    }
+    else hScrollbar->hide();
+
+    if(showhscrollbar == 1)  {
+        lines = lines - (hwidth / font_h) - 1;
+        if(lines < 1) lines = 1;
+    }
+
+      /*//FIXME: set rimX == rimY == 0 when running in full screen mode.
+  Config cfg("Konsole");
+  cfg.setGroup("ScrollBar");
+  useHorzScroll=cfg.readBoolEntry("HorzScroll",0);
+
+  scrollbar->resize( QApplication::style().scrollBarExtent().width(),
                     contentsRect().height());
+  qDebug("font_w %d", font_w);
   switch(scrollLoc)
   {
     case SCRNONE :
      columns = ( contentsRect().width() - 2 * rimX ) / font_w;
      blX = (contentsRect().width() - (columns*font_w) ) / 2;
      brX = blX;
      scrollbar->hide();
      break;
     case SCRLEFT :
      columns = ( contentsRect().width() - 2 * rimX - scrollbar->width()) / font_w;
+     if(useHorzScroll) columns = columns * (font_w/2);
      brX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
      blX = brX + scrollbar->width();
      scrollbar->move(contentsRect().topLeft());
      scrollbar->show();
      break;
     case SCRRIGHT:
-     columns = ( contentsRect().width()  - 2 * rimX - scrollbar->width()) / font_w;
-     blX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
-     brX = blX;
-     scrollbar->move(contentsRect().topRight() - QPoint(scrollbar->width()-1,0));
+      columns = ( contentsRect().width()  - 2 * rimX - scrollbar->width() ) / font_w;
+      if(useHorzScroll) columns = columns * (font_w/2);
+      blX = (contentsRect().width() - (columns*font_w) - scrollbar->width() ) / 2;
+      if(useHorzScroll) {
+          brX = blX =2;
+      } else {
+         brX=blX;
+      }
+     scrollbar->move(contentsRect().topRight() - QPoint(scrollbar->width()-1,0) );
      scrollbar->show();
      break;
   }
+
+   if( !scrollbar->isHidden())
+       hScrollbar->resize( contentsRect().width()-SCRWIDTH, QApplication::style()
+                      .scrollBarExtent().height());
+   else
+       hScrollbar->resize( contentsRect().width(), QApplication::style()
+                      .scrollBarExtent().height());
+
+   hScrollbar->move( 0, contentsRect().height() - SCRWIDTH);
+      
+
+  if(useHorzScroll) {
+      hScrollbar->show();
+      lines   = ( (contentsRect().height() - SCRWIDTH)  - 2 * rimY  ) / font_h;
+      bY = ((contentsRect().height() - SCRWIDTH) - (lines  *font_h)) / 2;
+  } else {
+      hScrollbar->hide();
+      lines   = (contentsRect().height()  - 2 * rimY  ) / font_h;
+      bY = (contentsRect().height() - (lines  *font_h)) / 2;
+  }     
+      */      
   //FIXME: support 'rounding' styles
-  lines   = ( contentsRect().height() - 2 * rimY  ) / font_h;
-  bY = (contentsRect().height() - (lines  *font_h)) / 2;
 }
 
 void TEWidget::makeImage()
 //FIXME: rename 'calcGeometry?
 {
   calcGeometry();
   image = (ca*) malloc(lines*columns*sizeof(ca));
   clearImage();
 }
 
 // calculate the needed size
 QSize TEWidget::calcSize(int cols, int lins) const
 {
   int frw = width() - contentsRect().width();
   int frh = height() - contentsRect().height();
   int scw = (scrollLoc==SCRNONE?0:scrollbar->width());
   return QSize( font_w*cols + 2*rimX + frw + scw, font_h*lins + 2*rimY + frh );
 }
 
 QSize TEWidget::sizeHint() const
 {
    return size();
 }
 
@@ -1245,24 +1376,32 @@ void TEWidget::drop_menu_activated(int item)
       break;
     case 1: // cd ...
       currentSession->getEmulation()->sendString("cd ");
       struct stat statbuf;
       if ( ::stat( QFile::encodeName( dropText ), &statbuf ) == 0 )
       {
         if ( !S_ISDIR(statbuf.st_mode) )
         {
 /*
           KURL url;
           url.setPath( dropText );
           dropText = url.directory( true, false ); // remove filename
 */
         }
       }
       dropText.replace(QRegExp(" "), "\\ "); // escape spaces
       currentSession->getEmulation()->sendString(dropText.local8Bit());
       currentSession->getEmulation()->sendString("\n");
 //    KWM::activate((Window)this->winId());
       break;
   }
 #endif
 }
 
+void TEWidget::setWrapAt(int columns)
+{
+  vcolumns = columns;
+    propagateSize();
+    update();
+}
+
+
diff --git a/core/apps/embeddedkonsole/TEWidget.h b/core/apps/embeddedkonsole/TEWidget.h
index 40e1aea..a480d45 100644
--- a/core/apps/embeddedkonsole/TEWidget.h
+++ b/core/apps/embeddedkonsole/TEWidget.h
@@ -39,85 +39,90 @@ class TEWidget : public QFrame
 // a widget representing attributed text
 { Q_OBJECT
 
 //  friend class Konsole;
 
 public:
 
     TEWidget(QWidget *parent=0, const char *name=0);
     virtual ~TEWidget();
 
 public:
 
     QColor getDefaultBackColor();
 
     const ColorEntry* getColorTable() const;
     const ColorEntry* getdefaultColorTable() const;
     void              setColorTable(const ColorEntry table[]);
 
     void setScrollbarLocation(int loc);
     enum { SCRNONE=0, SCRLEFT=1, SCRRIGHT=2 };
 
     void setScroll(int cursor, int lines);
     void doScroll(int lines);
 
+    void doHScroll(int lines);
+
+    
     void emitSelection();
+  void setWrapAt(int columns);
 
 public:
 
     void setImage(const ca* const newimg, int lines, int columns);
 
     int  Lines()   { return lines;   }
     int  Columns() { return columns; }
 
     void calcGeometry();
     void propagateSize();
     QSize calcSize(int cols, int lins) const;
 
     QSize sizeHint() const;
 
 public:
+    bool useHorzScroll;
 
     void Bell();
     void emitText(QString text);
     void pasteClipboard();
 
 signals:
 
     void keyPressedSignal(QKeyEvent *e);
     void mouseSignal(int cb, int cx, int cy);
     void changedImageSizeSignal(int lines, int columns);
     void changedHistoryCursor(int value);
+    void changedHorzCursor(int value);
     void configureRequest( TEWidget*, int state, int x, int y );
 
     void clearSelectionSignal();
     void beginSelectionSignal( const int x, const int y );
     void extendSelectionSignal( const int x, const int y );
     void endSelectionSignal(const BOOL preserve_line_breaks);
 
 
 protected:
-
     virtual void styleChange( QStyle& );
 
     bool eventFilter( QObject *, QEvent * );
 
     void drawAttrStr(QPainter &paint, QRect rect,
                      QString& str, ca attr, BOOL pm, BOOL clear);
     void paintEvent( QPaintEvent * );
 
     void resizeEvent(QResizeEvent*);
 
     void fontChange(const QFont &font);
     void frameChanged();
 
     void mouseDoubleClickEvent(QMouseEvent* ev);
     void mousePressEvent( QMouseEvent* );
     void mouseReleaseEvent( QMouseEvent* );
     void mouseMoveEvent( QMouseEvent* );
 
     void focusInEvent( QFocusEvent * );
     void focusOutEvent( QFocusEvent * );
     bool focusNextPrevChild( bool next );
 
 #ifndef QT_NO_DRAGANDDROP
     // Dnd
@@ -126,77 +131,81 @@ protected:
 #endif
 
     virtual int charClass(char) const;
 
     void clearImage();
 
 public:
     const QPixmap *backgroundPixmap();
     
     void setSelection(const QString &t);
 
     virtual void setFont(const QFont &);
     void setVTFont(const QFont &);
     QFont getVTFont();
 
     void setMouseMarks(bool on);
 
 public slots:
 
     void onClearSelection();
 
 protected slots:
 
     void scrollChanged(int value);
+    void hScrollChanged(int value);
     void blinkEvent();
 
 private:
 
     QChar (*fontMap)(QChar); // possible vt100 font extention
 
     bool fixed_font; // has fixed pitch
     int  font_h;     // height
     int  font_w;     // width
     int  font_a;     // ascend
 
     int blX;    // actual offset (left)
     int brX;    // actual offset (right)
     int bY;     // actual offset
 
     int lines;
     int columns;
     ca *image; // [lines][columns]
 
     ColorEntry color_table[TABLE_COLORS];
 
     BOOL resizing;
     bool mouse_marks;
 
     void makeImage();
 
     QPoint iPntSel; // initial selection point
     QPoint pntSel; // current selection point
     int    actSel; // selection state
     BOOL    word_selection_mode;
     BOOL    preserve_line_breaks;
 
     QClipboard*    cb;
-    QScrollBar* scrollbar;
-    int         scrollLoc;
+    QScrollBar* scrollbar, *hScrollbar;
+    
+    int         scrollLoc, hScrollLoc;
+  int hposition, vcolumns;
 
+    
 //#define SCRNONE  0
 //#define SCRLEFT  1
 //#define SCRRIGHT 2
 
     BOOL blinking;   // hide text in paintEvent
     BOOL hasBlinker; // has characters to blink
     QTimer* blinkT;  // active when hasBlinker
     QPopupMenu* m_drop;
     QString dropText;
  public:
     // current session in this widget
     TESession *currentSession;
 private slots:
     void drop_menu_activated(int item);
 };
 
 #endif // TE_WIDGET_H
diff --git a/core/apps/embeddedkonsole/TEmulation.cpp b/core/apps/embeddedkonsole/TEmulation.cpp
index 6f3ad32..c19f2a1 100644
--- a/core/apps/embeddedkonsole/TEmulation.cpp
+++ b/core/apps/embeddedkonsole/TEmulation.cpp
@@ -1,40 +1,40 @@
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* [TEmulation.cpp]        Terminal Emulation Decoder                         */
 /*                                                                            */
 /* -------------------------------------------------------------------------- */
 /*                                                                            */
 /* 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>                  */
-        /*                                                                    */
+/*                        */
 /* -------------------------------------------------------------------------- */
 
 /*! \class TEmulation
 
     \brief Mediator between TEWidget and TEScreen.
 
    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 TEWidget by certain rules.
 
    \sa TEWidget \sa TEScreen
 
    \par A note on refreshing
 
    Although the modifications to the current screen image could immediately
    be propagated via `TEWidget' 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
@@ -82,62 +82,72 @@
 /*                                                                           */
 /*                               TEmulation                                  */
 /*                                                                           */
 /* ------------------------------------------------------------------------- */
 
 #define CNTL(c) ((c)-'@')
 
 /*!
 */
 
 TEmulation::TEmulation(TEWidget* gui)
 : decoder((QTextDecoder*)NULL)
 {
   this->gui = gui;
 
   screen[0] = new TEScreen(gui->Lines(),gui->Columns());
   screen[1] = new TEScreen(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)),
                    this,SLOT(onImageSizeChange(int,int)));
+
   QObject::connect(gui,SIGNAL(changedHistoryCursor(int)),
                    this,SLOT(onHistoryCursorChange(int)));
+
+  QObject::connect(gui,SIGNAL(changedHorzCursor(int)),
+                   this,SLOT(onHorzCursorChange(int)));
+
   QObject::connect(gui,SIGNAL(keyPressedSignal(QKeyEvent*)),
                    this,SLOT(onKeyPress(QKeyEvent*)));
+
   QObject::connect(gui,SIGNAL(beginSelectionSignal(const int,const int)),
-                   this,SLOT(onSelectionBegin(const int,const int)) );
+       this,SLOT(onSelectionBegin(const int,const int)) );
+
   QObject::connect(gui,SIGNAL(extendSelectionSignal(const int,const int)),
-                   this,SLOT(onSelectionExtend(const int,const int)) );
+       this,SLOT(onSelectionExtend(const int,const int)) );
+
   QObject::connect(gui,SIGNAL(endSelectionSignal(const BOOL)),
-                   this,SLOT(setSelection(const BOOL)) );
+       this,SLOT(setSelection(const BOOL)) );
+
   QObject::connect(gui,SIGNAL(clearSelectionSignal()),
-                   this,SLOT(clearSelection()) );
+       this,SLOT(clearSelection()) );
 }
 
 /*!
 */
 
 TEmulation::~TEmulation()
 {
   delete screen[0];
   delete screen[1];
   bulk_timer.stop();
 }
 
 /*! change between primary and alternate screen
 */
 
 void TEmulation::setScreen(int n)
 {
   scr = screen[n&1];
 }
 
 void TEmulation::setHistory(bool on)
 {
   screen[0]->setScroll(on);
   if (!connected) return;
@@ -278,86 +288,91 @@ void TEmulation::clearSelection() {
 /*!
    called when \n comes in. Evtl. triggers showBulk at endBulk
 */
 
 void TEmulation::bulkNewline()
 {
   bulk_nlcnt += 1;
   bulk_incnt = 0;  // reset bulk counter since `nl' rule applies
 }
 
 /*!
 */
 
 void TEmulation::showBulk()
 {
   bulk_nlcnt = 0;                       // reset bulk newline counter
   bulk_incnt = 0;                       // reset bulk counter
   if (connected)
   {
     ca* image = scr->getCookedImage();    // get the image
     gui->setImage(image,
                   scr->getLines(),
                   scr->getColumns());     // actual refresh
     free(image);
-    //FIXME: check that we do not trigger other draw event here.
+
+      //FIXME: check that we do not trigger other draw event here.
     gui->setScroll(scr->getHistCursor(),scr->getHistLines());
+
   }
 }
 
 void TEmulation::bulkStart()
 {
   if (bulk_timer.isActive()) bulk_timer.stop();
 }
 
 void TEmulation::bulkEnd()
 {
   if ( bulk_nlcnt > gui->Lines() || bulk_incnt > 20 )
     showBulk();                         // resets bulk_??cnt to 0, too.
   else
     bulk_timer.start(BULK_TIMEOUT,TRUE);
 }
 
 void TEmulation::setConnect(bool c)
 {
   connected = c;
   if ( connected)
   {
     onImageSizeChange(gui->Lines(), gui->Columns());
     showBulk();
   }
   else
   {
     scr->clearSelection();
   }
 }
 
 // ---------------------------------------------------------------------------
 
 /*!  triggered by image size change of the TEWidget `gui'.
 
     This event is simply propagated to the attached screens
     and to the related serial line.
 */
 
-void TEmulation::onImageSizeChange(int lines, int columns)
-{
+void TEmulation::onImageSizeChange(int lines, int columns) {
   if (!connected) return;
   screen[0]->resizeImage(lines,columns);
   screen[1]->resizeImage(lines,columns);
   showBulk();
   emit ImageSizeChanged(lines,columns);   // propagate event to serial line
 }
 
-void TEmulation::onHistoryCursorChange(int cursor)
-{
+void TEmulation::onHistoryCursorChange(int cursor) {
   if (!connected) return;
   scr->setHistCursor(cursor);
   showBulk();
 }
 
-void TEmulation::setColumns(int columns)
-{
+void TEmulation::onHorzCursorChange(int cursor) {
+  if (!connected) return;
+ scr->setHorzCursor(cursor);
+  showBulk();
+}
+
+void TEmulation::setColumns(int columns) {
   //FIXME: this goes strange ways.
   //       Can we put this straight or explain it at least?
   emit changeColumns(columns);
 }
diff --git a/core/apps/embeddedkonsole/konsole.cpp b/core/apps/embeddedkonsole/konsole.cpp
index a8ddc99..3c87ad4 100644
--- a/core/apps/embeddedkonsole/konsole.cpp
+++ b/core/apps/embeddedkonsole/konsole.cpp
@@ -337,63 +337,75 @@ void Konsole::init(const char* _pgm, QStrList & _args)
 
   editCommandListMenu->insertItem( tr( "Quick Edit" ) );
   if( listHidden) {
       secondToolBar->hide();
       editCommandListMenu->setItemEnabled(-23 ,FALSE);
   }
   editCommandListMenu->insertItem(tr(  "Edit" ) );
 
   cfg.setGroup("Commands");
   commonCombo->setInsertionPolicy(QComboBox::AtCurrent);
 
   initCommandList();
 //   for (int i = 0; commonCmds[i] != NULL; i++) {
 //        commonCombo->insertItem( commonCmds[i], i );
 //        tmp = cfg.readEntry( QString::number(i),"");
 //        if(tmp != "")
 //            commonCombo->changeItem( tmp,i );
 //    }
 
   connect( commonCombo, SIGNAL( activated(int) ), this, SLOT( enterCommand(int) ));
 
   scrollMenu->insertItem(tr( "None" ));
   scrollMenu->insertItem(tr( "Left" ));
   scrollMenu->insertItem(tr( "Right" ));
+  scrollMenu->insertSeparator(4);
+  scrollMenu->insertItem(tr( "Horizontal" ));
+ 
   configMenu->insertItem(tr( "ScrollBar" ),scrollMenu);
-
+//scrollMenuSelected(-29);
+//   cfg.setGroup("ScrollBar");
+//   if(cfg.readBoolEntry("HorzScroll",0)) {
+//       if(cfg.readNumEntry("Position",2) == 0)
+//           te->setScrollbarLocation(1);
+//       else
+//           te->setScrollbarLocation(0);
+//       te->setScrollbarLocation( cfg.readNumEntry("Position",2));
+//       te->setWrapAt(120);
+//   }
       // create applications /////////////////////////////////////////////////////
   setCentralWidget(tab);
 
   // load keymaps ////////////////////////////////////////////////////////////
   KeyTrans::loadAll();
   for (int i = 0; i < KeyTrans::count(); i++)
   { KeyTrans* s = KeyTrans::find(i);
     assert( s );
   }
 
   se_pgm = _pgm;
   se_args = _args;
-
+  se_args.prepend("--login");
 parseCommandLine();
   // read and apply default values ///////////////////////////////////////////
   resize(321, 321); // Dummy.
   QSize currentSize = size();
   if (currentSize != size())
      defaultSize = size();
 }
 
 void Konsole::show()
 {
   if ( !nsessions ) {
     newSession();
   }
   QMainWindow::show();
 }
 
 void Konsole::initSession(const char*, QStrList &)
 {
   QMainWindow::show();
 }
 
 Konsole::~Konsole()
 {
     while (nsessions > 0) {
@@ -487,92 +499,95 @@ void Konsole::hitDown()
 }
 
 /**
    This function calculates the size of the external widget
    needed for the internal widget to be
  */
 QSize Konsole::calcSize(int columns, int lines) {
     TEWidget* te = getTe();
     if (te != 0) {
     QSize size = te->calcSize(columns, lines);
     return size;
     } else {
   QSize size;
   return size;
     }
 }
 
 /**
     sets application window to a size based on columns X lines of the te
     guest widget. Call with (0,0) for setting default size.
 */
 
 void Konsole::setColLin(int columns, int lines)
 {
+  qDebug("konsole::setColLin:: Columns %d", columns);
+    
   if ((columns==0) || (lines==0))
   {
     if (defaultSize.isEmpty()) // not in config file : set default value
     {
       defaultSize = calcSize(80,24);
       // notifySize(24,80); // set menu items (strange arg order !)
     }
     resize(defaultSize);
   } else {
     resize(calcSize(columns, lines));
     // notifySize(lines,columns); // set menu items (strange arg order !)
   }
 }
 
 /*
 void Konsole::setFont(int fontno)
 {
   QFont f;
   if (fontno == 0)
     f = defaultFont = QFont( "Helvetica", 12  );
   else
   if (fonts[fontno][0] == '-')
     f.setRawName( fonts[fontno] );
   else
   {
     f.setFamily(fonts[fontno]);
     f.setRawMode( TRUE );
   }
   if ( !f.exactMatch() && fontno != 0)
   {
     QString msg = i18n("Font `%1' not found.\nCheck README.linux.console for help.").arg(fonts[fontno]);
     QMessageBox(this,  msg);
     return;
   }
   if (se) se->setFontNo(fontno);
   te->setVTFont(f);
   n_font = fontno;
 }
 */
 
 // --| color selection |-------------------------------------------------------
 
 void Konsole::changeColumns(int columns)
 {
+    qDebug("change columns");
   TEWidget* te = getTe();
   if (te != 0) {
   setColLin(columns,te->Lines());
   te->update();
   }
 }
 
 //FIXME: If a child dies during session swap,
 //       this routine might be called before
 //       session swap is completed.
 
 void Konsole::doneSession(TESession*, int )
 {
   TEWidget *te = getTe();
   if (te != 0) {
     te->currentSession->setConnect(FALSE);
     tab->removeTab(te);
     delete te->currentSession;
     delete te;
     nsessions--;
   }
 
   if (nsessions == 0) {
   close();
@@ -779,66 +794,77 @@ void Konsole::configMenuSelected(int iD)
     }
 }
 
 void Konsole::changeCommand(const QString &text, int c)
 {
     Config cfg("Konsole");
     cfg.setGroup("Commands");
     if(commonCmds[c] != text) {
         cfg.writeEntry(QString::number(c),text);
         commonCombo->clearEdit();
         commonCombo->setCurrentItem(c);
     }
 }
 
 void Konsole::setColor()
 {
     Config cfg("Konsole");
     cfg.setGroup("Colors");
     int scheme = cfg.readNumEntry("Schema",1);
     if(scheme != 1) colorMenuSelected( -scheme);
 }
 
 void Konsole::scrollMenuSelected(int index)
 {
-//      QString temp;
-//      qDebug( temp.sprintf("scrollbar menu %d",index));
+    qDebug( "scrollbar menu %d",index);
     TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("ScrollBar");
     switch( index){
     case -25:
         te->setScrollbarLocation(0);
         cfg.writeEntry("Position",0);
         break;
     case -26:
         te->setScrollbarLocation(1);
         cfg.writeEntry("Position",1);
         break;
     case -27:
         te->setScrollbarLocation(2);
         cfg.writeEntry("Position",2);
         break;
+      case -29: {
+          bool b=cfg.readBoolEntry("HorzScroll",0);
+          cfg.writeEntry("HorzScroll", !b );
+          cfg.write();
+          if(cfg.readNumEntry("Position",2) == 0)
+              te->setScrollbarLocation(1);
+          else
+              te->setScrollbarLocation(0);
+          te->setScrollbarLocation( cfg.readNumEntry("Position",2));
+          te->setWrapAt(120);
+      }
+        break;
     };
 
 }
 
 void Konsole::editCommandListMenuSelected(int iD)
 {
 //      QString temp;
 //      qDebug( temp.sprintf("edit command list %d",iD));
     TEWidget* te = getTe();
     Config cfg("Konsole");
     cfg.setGroup("Menubar");
     if( iD  == -3) {
         if(!secondToolBar->isHidden()) {
             secondToolBar->hide();
             configMenu->changeItem( iD,tr( "Show Command List" ));
             cfg.writeEntry("Hidden","TRUE");
             configMenu->setItemEnabled(-23 ,FALSE);
         } else {
             secondToolBar->show();
             configMenu->changeItem( iD,tr( "Hide Command List" ));
             cfg.writeEntry("Hidden","FALSE");
             configMenu->setItemEnabled(-23 ,TRUE);
 
             if(cfg.readEntry("EditEnabled","FALSE")=="TRUE") {