Major modifications to the User Interface

		1) Bookmark support added, all options are stored on a per bookmark basis
		2) 16 Bit color is now a supported bit depth for the server

20 files changed, 682 insertions, 523 deletions

diff --git a/noncore/comm/keypebble/keypebble.pro b/noncore/comm/keypebble/keypebble.pro
index a102381..1017133 100644
--- a/noncore/comm/keypebble/keypebble.pro
+++ b/noncore/comm/keypebble/keypebble.pro
@@ -1,47 +1,49 @@
 TEMPLATE        = app
 CONFIG          += qt warn_on release
 DESTDIR         = $(OPIEDIR)/bin
         HEADERS         = d3des.h \
                   krfbbuffer.h \
                   krfbcanvas.h \
                   krfbconnection.h \
                   krfbdecoder.h \
                   krfblogin.h \
-                  krfboptions.h \
+                  krfbserver.h \
                   krfbserverinfo.h \
                   kvnc.h \
-                  kvncconnectdlg.h \
-                  kvncoptionsdlg.h \
+                  kvncconndlg.h \
+                  kvncbookmarkdlg.h \
+                  version.h \
                   vncauth.h
         SOURCES         = d3des.c \
                   vncauth.c \
                   krfbbuffer.cpp \
                   krfbcanvas.cpp \
                   krfbconnection.cpp \
                   krfbdecoder.cpp \
                   krfblogin.cpp \
-                  krfboptions.cpp \
+                  krfbserver.cpp \
                   kvnc.cpp \
-                  kvncconnectdlg.cpp \
-                  kvncoptionsdlg.cpp \
+                  kvncconndlg.cpp \
+                  kvncbookmarkdlg.cpp \
                   main.cpp
-        INTERFACES= vncoptionsbase.ui
+        INTERFACES= kvncconndlgbase.ui \
+                                                kvncbookmarkdlgbase.ui
 TARGET          = keypebble
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH      += $(OPIEDIR)/include
 LIBS            += -lqpe
 
 TRANSLATIONS = ../../../i18n/de/keypebble.ts \
          ../../../i18n/en/keypebble.ts \
          ../../../i18n/es/keypebble.ts \
          ../../../i18n/fr/keypebble.ts \
          ../../../i18n/hu/keypebble.ts \
          ../../../i18n/ja/keypebble.ts \
          ../../../i18n/ko/keypebble.ts \
          ../../../i18n/no/keypebble.ts \
          ../../../i18n/pl/keypebble.ts \
          ../../../i18n/pt/keypebble.ts \
          ../../../i18n/pt_BR/keypebble.ts \
          ../../../i18n/sl/keypebble.ts \
          ../../../i18n/zh_CN/keypebble.ts \
          ../../../i18n/zh_TW/keypebble.ts
diff --git a/noncore/comm/keypebble/krfbbuffer.cpp b/noncore/comm/keypebble/krfbbuffer.cpp
index 4885261..5a52f31 100644
--- a/noncore/comm/keypebble/krfbbuffer.cpp
+++ b/noncore/comm/keypebble/krfbbuffer.cpp
@@ -1,163 +1,194 @@
 #include <assert.h>
 #include <qpixmap.h>
 #include <qbrush.h>
 #include <qimage.h>
 #include <qpainter.h>
 #include <qapplication.h>
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 #include "krfbserverinfo.h"
 
 //
 // Endian stuff
 //
 #ifndef KDE_USE_FINAL
 const int endianTest = 1;
 #endif
 
 #define Swap16IfLE(s) \
     (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))
 
 #define Swap32IfLE(l) \
     (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \
                              (((l) & 0x00ff0000) >> 8)  | \
                              (((l) & 0x0000ff00) << 8)  | \
                              (((l) & 0x000000ff) << 24))  : (l))
 
 KRFBBuffer::KRFBBuffer( KRFBDecoder *decoder,
                         QObject *parent, const char *name )
   : QObject( parent, name )
 {
   assert( decoder );
   this->decoder = decoder;
   pix = new QPixmap();
 }
 
 KRFBBuffer::~KRFBBuffer()
 {
   delete pix;
 }
 
 void KRFBBuffer::resize( int w, int h )
 {
   qWarning( "Resizing buffer" );
 
   pix->resize( w, h );
   
   QPalette pal = qApp->palette();
   pix->fill( pal.active().base() );
 
   emit sizeChanged( w, h );
 }
 
 void KRFBBuffer::soundBell()
 {
   emit bell();
 }
 
 void KRFBBuffer::mouseEvent( QMouseEvent *e )
 {
   decoder->sendMouseEvent( e );
 }
 
 void KRFBBuffer::keyPressEvent( QKeyEvent *e )
 {
     qWarning( "Buffer got a key" );
 
   decoder->sendKeyPressEvent( e );
 }
 
 void KRFBBuffer::keyReleaseEvent( QKeyEvent *e )
 {
   decoder->sendKeyReleaseEvent( e );
 }
 
 void KRFBBuffer::copyRect( int srcX, int srcY,
                            int destX, int destY, int w, int h )
 {
 //  qWarning( "Got copy rect" );
   bitBlt( pix, destX, destY, pix, srcX, srcY, w, h, CopyROP );
 
   emit updated( destX, destY, w, h );
 }
 
 void KRFBBuffer::drawRawRectChunk( void *data,
                                    int x, int y, int w, int h )
 {
   QImage img( w, h, 32 );
 
   int redMax = Swap16IfLE( decoder->format->redMax );
   int greenMax = Swap16IfLE( decoder->format->greenMax );
   int blueMax = Swap16IfLE( decoder->format->blueMax );
 
   QPainter p( pix );
 
   if ( decoder->format->bpp == 8 ) {
     uchar *d = (unsigned char *) data;
 
     uint r,g,b;
 
     for ( int j = 0; j < h; j++ ) {
       for ( int i = 0; i < w ; i++ ) {
         r = d[ j * w + i ];
         r = r >> decoder->format->redShift;
         r = r & redMax;
 
         g = d[ j * w + i ];
         g = g >> decoder->format->greenShift;
         g = g & greenMax;
 
         b = d[ j * w + i ];
         b = b >> decoder->format->blueShift;
         b = b & blueMax;
 
         r = ( r * 255 ) / redMax;
         g = ( g * 255 ) / greenMax;
         b = ( b * 255 ) / blueMax;
 
         uint *p = ( uint * ) img.scanLine( j ) + i;
         *p = qRgb( r,g,b );
       }
     }
   }
   else if ( decoder->format->bpp == 32 ) {
     ulong *d = (ulong *) data;
 
     ulong r,g,b;
 
     for ( int j = 0; j < h; j++ ) {
       for ( int i = 0; i < w ; i++ ) {
         ulong pixel = d[ j * w + i ];
         pixel = Swap32IfLE( pixel );
 
         r = pixel;
         r = r >> decoder->format->redShift;
         r = r & redMax;
 
         g = pixel;
         g = g >> decoder->format->greenShift;
         g = g & greenMax;
 
         b = pixel;
         b = b >> decoder->format->blueShift;
         b = b & blueMax;
 
         r = ( r * 255 ) / redMax;
         g = ( g * 255 ) / greenMax;
         b = ( b * 255 ) / blueMax;
 
         uint *p = ( uint * ) img.scanLine( j ) + i;
         *p = qRgb( r,g,b );
       }
     }
-  }
+  } else if (decoder->format->bpp == 16 ) {
+
+                                CARD16 *d = (CARD16 *) data;
+
+                                uint r,g,b;
+
+                                for ( int j = 0; j < h; j++ ) {
+                                                for ( int i = 0; i < w ; i++ ) {
+                                                                CARD16 pixel = d[ j * w + i ];
+                                                                pixel = Swap16IfLE( pixel );
+
+                                                                r = pixel;
+                                                                r = r >> decoder->format->redShift;
+                                                                r = r & redMax;
+
+                                                                g = pixel;
+                                                                g = g >> decoder->format->greenShift;
+                                                                g = g & greenMax;
+
+                                                                b = pixel;
+                                                                b = b >> decoder->format->blueShift;
+                                                                b = b & blueMax;
+
+                                                                r = ( r * 255 ) / redMax;
+                                                                g = ( g * 255 ) / greenMax;
+                                                                b = ( b * 255 ) / blueMax;
+
+                                                                ulong *p = ( ulong * ) img.scanLine( j ) + i;
+                                                                *p = qRgb( r,g,b );
+                                                }
+                                }
+                }
   else {
     p.setBrush( QBrush( Qt::black ) );
     p.drawRect( x, y, w, h );
   }
 
   p.drawImage( x, y, img );
 
   emit updated( x, y, w, h );
 }
 
diff --git a/noncore/comm/keypebble/krfbcanvas.cpp b/noncore/comm/keypebble/krfbcanvas.cpp
index f74ab7b..8b56795 100644
--- a/noncore/comm/keypebble/krfbcanvas.cpp
+++ b/noncore/comm/keypebble/krfbcanvas.cpp
@@ -1,169 +1,172 @@
-#include "kvncconnectdlg.h"
 #include "krfbconnection.h"
 #include "krfbcanvas.h"
-#include "krfboptions.h"
+#include "krfbserver.h"
 #include "krfbbuffer.h"
 
 #include <qpe/config.h>
+#include <qpe/qpeapplication.h>
 
 #include <qapplication.h>
 #include <qclipboard.h>
 #include <qaction.h>
 #include <qpixmap.h>
 #include <qapplication.h>
 #include <qmainwindow.h>
 #include <qiconset.h>
 
 KRFBCanvas::KRFBCanvas( QWidget *parent, const char *name )
   : QScrollView( parent, name )
 {
     connection_ = new KRFBConnection();
-    connect( connection_, SIGNAL( passwordRequired( KRFBConnection * ) ),
-            this, SLOT( passwordRequired( KRFBConnection * ) ) );
     connect( connection_, SIGNAL( loggedIn() ),
             this, SLOT( loggedIn() ) );
 
     loggedIn_ = false;
+                QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold);
 
     viewport()->setFocusPolicy( QWidget::StrongFocus );
     viewport()->setFocus();
 }
 
 KRFBCanvas::~KRFBCanvas()
 {
 }
 
-void KRFBCanvas::openConnection()
+
+void KRFBCanvas::openConnection(KRFBServer server)
 {
-  KVNCConnectDlg dlg( connection_, this, "connect dialog" );
-  if ( dlg.exec() ) {
-    QCString host = dlg.hostname().latin1();
-    password = dlg.password();
-    connection_->connectTo( host, dlg.display() );
-  }
+
+  
+                QCString host = server.hostname.latin1();
+                password=server.password;
+                connection_->connectTo( server);
 }
 
+
 void KRFBCanvas::openURL( const QUrl &url )
 {
   if ( loggedIn_ ) {
       qWarning( "openURL invoked when logged in\n" );
       return;
   }
 
   QCString host = url.host().latin1();
   int display = url.port();
-  if ( url.hasPassword() )
-    connection_->setPassword( url.password().latin1() );
 
-  connection_->connectTo( host, display );
+//  connection_->connectTo( host, display );
 }
 
 void KRFBCanvas::closeConnection()
 {
   loggedIn_ = false;
   connection_->disconnect();
 
   viewport()->setMouseTracking( false );
   viewport()->setBackgroundMode( PaletteDark );
   setBackgroundMode( PaletteDark );
   update();
 }
 
-void KRFBCanvas::passwordRequired( KRFBConnection *con )
-{
-  con->setPassword( password.latin1() );
-}
 
 void KRFBCanvas::bell()
 {
   if ( connection_->options()->deIconify ) {
     topLevelWidget()->raise();
     topLevelWidget()->show();
   }
 }
 
 void KRFBCanvas::loggedIn()
 {
   qWarning( "Ok, we're logged in" );
 
   //
   // Get ready for action
   //
   loggedIn_ = true;
   viewport()->setMouseTracking( true );
   viewport()->setBackgroundMode( NoBackground );
   setBackgroundMode( NoBackground );
 
   // Start using the buffer
   connect( connection_->buffer(), SIGNAL( sizeChanged( int, int ) ),
            this, SLOT( resizeContents(int,int) ) );
   connect( connection_->buffer(), SIGNAL( updated( int, int, int, int ) ),
            this, SLOT( viewportUpdate(int,int,int,int) ) );
   connect( connection_->buffer(), SIGNAL( bell() ),
            this, SLOT( bell() ) );
   connect( qApp->clipboard(), SIGNAL( dataChanged() ),
            this, SLOT( clipboardChanged() ) );
 }
 
 void KRFBCanvas::viewportPaintEvent( QPaintEvent *e )
 {
   QRect r = e->rect();
 
   if ( loggedIn_ ) {
     bitBlt( viewport(), r.x(), r.y(),
             connection_->buffer()->pixmap(),
             r.x() + contentsX(), r.y() + contentsY(),
             r.width(), r.height() );
   }
   else {
     QScrollView::viewportPaintEvent( e );
   }
 }
 
 void KRFBCanvas::viewportUpdate( int x, int y, int w, int h )
 {
   updateContents( x, y, w, h );
 }
 
 void KRFBCanvas::contentsMousePressEvent( QMouseEvent *e )
 {
   if ( loggedIn_ )
     connection_->buffer()->mouseEvent( e );
 }
 
 void KRFBCanvas::contentsMouseReleaseEvent( QMouseEvent *e )
 {
   if ( loggedIn_ )
     connection_->buffer()->mouseEvent( e );
 }
 
 void KRFBCanvas::contentsMouseMoveEvent( QMouseEvent *e )
 {
   if ( loggedIn_ )
     connection_->buffer()->mouseEvent( e );
 }
 
 void KRFBCanvas::keyPressEvent( QKeyEvent *e )
 {
   if ( loggedIn_ )
     connection_->buffer()->keyPressEvent( e );
 }
 
 void KRFBCanvas::keyReleaseEvent( QKeyEvent *e )
 {
   if ( loggedIn_ )
     connection_->buffer()->keyReleaseEvent( e );
 }
 
 void KRFBCanvas::refresh()
 {
   if ( loggedIn_ )
     connection_->refresh();
 }
 
 void KRFBCanvas::clipboardChanged()
 {
   if ( loggedIn_ ) {
       connection_->sendCutText( qApp->clipboard()->text() );
   }
 }
+void KRFBCanvas::sendCtlAltDel( void)
+{
+
+                qDebug("Here");
+  if ( loggedIn_ ) {
+    connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyPress,Qt::Key_Delete, 0x7f,ControlButton|AltButton));
+ //   connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyRelease,Qt::Key_Delete, 0x7f,ControlButton|AltButton));
+        }
+}
diff --git a/noncore/comm/keypebble/krfbcanvas.h b/noncore/comm/keypebble/krfbcanvas.h
index 7864f1c..cd3047c 100644
--- a/noncore/comm/keypebble/krfbcanvas.h
+++ b/noncore/comm/keypebble/krfbcanvas.h
@@ -1,54 +1,56 @@
 // -*- c++ -*-
 
 #ifndef KRFBCANVAS_H
 #define KRFBCANVAS_H
 
 #include <qscrollview.h>
 #include <qurl.h>
 
 class KRFBConnection;
+class KRFBServer;
 
 /**
  * Displays data from an KRFBDecoder, and sends events to the
  * KRFBConnection.
  */
 class KRFBCanvas : public QScrollView
 {
   Q_OBJECT
 public:
   KRFBCanvas( QWidget *parent, const char *name=0 );
   ~KRFBCanvas();
 
   void setConnection( KRFBConnection * );
   KRFBConnection *connection() { return connection_; };
 
 public slots:
-  void openConnection();
+
+  void openConnection (KRFBServer);
   void openURL( const QUrl & );
   void closeConnection();
-  void passwordRequired( KRFBConnection * );
 
   void refresh();
   void bell();
+  void sendCtlAltDel(void);
 
 protected:
   virtual void keyPressEvent( QKeyEvent * );
   virtual void keyReleaseEvent( QKeyEvent * );
   virtual void contentsMousePressEvent( QMouseEvent * );
   virtual void contentsMouseReleaseEvent( QMouseEvent * );
   virtual void contentsMouseMoveEvent( QMouseEvent * );
 
   virtual void viewportPaintEvent( QPaintEvent *e );
 
 protected slots:
   void loggedIn();
   void viewportUpdate( int x, int y, int w, int h );
   void clipboardChanged();
 
 private:
   KRFBConnection *connection_;
   QString password;
   bool loggedIn_;
 };
 
 #endif // KRFBCANVAS_H
diff --git a/noncore/comm/keypebble/krfbconnection.cpp b/noncore/comm/keypebble/krfbconnection.cpp
index c51f18a..389c836 100644
--- a/noncore/comm/keypebble/krfbconnection.cpp
+++ b/noncore/comm/keypebble/krfbconnection.cpp
@@ -1,242 +1,234 @@
 #include <assert.h>
 #include <qsocket.h>
 #include <qtimer.h>
 #include <string.h>
 
 #include "krfbconnection.h"
 #include "krfblogin.h"
-#include "krfboptions.h"
+#include "krfbserver.h"
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 
 KRFBConnection::KRFBConnection( QObject *parent )
-    : QObject( parent, "KRFBConnection" )
+                : QObject( parent, "KRFBConnection" )
 {
-  portBase_ = 5900;
-  currentState_ = Disconnected;
-  sock = 0;
-  minData_ = 0;
-  options_ = new KRFBOptions();
-  updater = 0;
-  decoder_ = 0;
-  buffer_ = 0;
+                portBase_ = 5900;
+                currentState_ = Disconnected;
+                sock = 0;
+                minData_ = 0;
+                options_ = new KRFBServer();
+                updater = 0;
+                decoder_ = 0;
+                buffer_ = 0;
 }
 
 KRFBConnection::~KRFBConnection()
 {
-  if ( ( currentState_ != Disconnected ) && ( currentState_ != Disconnecting ) && sock ) {
-    disconnectDone();
-  }
-  delete options_;
+                if ( ( currentState_ != Disconnected ) && ( currentState_ != Disconnecting ) && sock ) {
+                                disconnectDone();
+                }
+                delete options_;
 }
 
-void KRFBConnection::connectTo( const QCString &host, int display )
+void KRFBConnection::connectTo( KRFBServer server)
 {
-  if ( currentState_ != Disconnected );
-    disconnect();
+                if ( currentState_ != Disconnected )
+                                disconnect();
+                
+    (*options_)=server;
 
-  this->host_= host;
-  this->display_ = display;
+                sock = new QSocket( this, "rfbSocket" );
+                CHECK_PTR( sock );
 
-  sock = new QSocket( this, "rfbSocket" );
-  CHECK_PTR( sock );
+                // Connect to something to notice connection or error
+                connect( sock, SIGNAL( error( int ) ), SLOT( gotSocketError( int ) ) );
+                connect( sock, SIGNAL( connected() ), SLOT( gotSocketConnection() ) );
 
-  // Connect to something to notice connection or error
-  connect( sock, SIGNAL( error( int ) ), SLOT( gotSocketError( int ) ) );
-  connect( sock, SIGNAL( connected() ), SLOT( gotSocketConnection() ) );
+                qWarning( "Connecting..." );
 
-  qWarning( "Connecting..." );
-
-  currentState_ = Connecting;
-  sock->connectToHost( host_, portBase_ + display_ );
+                currentState_ = Connecting;
+                sock->connectToHost( options_->hostname.latin1(), portBase_ + options_->display );
 }
 
 void KRFBConnection::disconnect()
 {
-    qWarning( "Disconnecting from server" );
+                qWarning( "Disconnecting from server" );
 
-  if ( ( currentState_ != Disconnected )
-       && ( currentState_ != Disconnecting )
-       && sock ) {
-    currentState_ = Disconnecting;
+                if ( ( currentState_ != Disconnected )
+                                                && ( currentState_ != Disconnecting )
+                                                && sock ) {
+                                currentState_ = Disconnecting;
 
-    connect( sock, SIGNAL( delayedCloseFinished() ), SLOT( disconnectDone() ) );
-    sock->close();
+                                connect( sock, SIGNAL( delayedCloseFinished() ), SLOT( disconnectDone() ) );
+                                sock->close();
 
-    if ( sock->state() != QSocket::Closing )
-      disconnectDone();
-  }
+                                if ( sock->state() != QSocket::Closing )
+                                                disconnectDone();
+                }
 }
 
 void KRFBConnection::disconnectDone()
 {
-  qWarning( "KRFBConnection disconnected" );
-  currentState_ = Disconnected;
-  delete sock;
-  sock = 0;
-  minData_ = 0;
-  delete updater;
-  delete decoder_;
-  delete buffer_;
-  emit disconnected();
+                currentState_ = Disconnected;
+                delete sock;
+                sock = 0;
+                minData_ = 0;
+                delete updater;
+                delete decoder_;
+                delete buffer_;
+                emit disconnected();
 }
 
 void KRFBConnection::gotSocketConnection()
 {
-  currentState_ = LoggingIn;
+                currentState_ = LoggingIn;
 
-  qWarning( "Connected, logging in..." );
+                qWarning( "Connected, logging in..." );
 
-  static QString statusMsg = tr( "Connected" );
-  emit statusChanged( statusMsg );
+                static QString statusMsg = tr( "Connected" );
+                emit statusChanged( statusMsg );
 
-  // Do some login stuff
-  login = new KRFBLogin( this );
+                // Do some login stuff
+                login = new KRFBLogin( this );
 }
 
 void KRFBConnection::gotRFBConnection()
 {
-  qWarning( "Logged into server" );
+                qWarning( "Logged into server" );
 
-  currentState_ = Connected;
-  emit connected();
+                currentState_ = Connected;
+                emit connected();
 
-  // Create the decoder and start doing stuff
-  decoder_ = new KRFBDecoder( this );
-  CHECK_PTR( decoder_ );
+                // Create the decoder and start doing stuff
+                decoder_ = new KRFBDecoder( this );
+                CHECK_PTR( decoder_ );
 
-  buffer_ = new KRFBBuffer( decoder_, this, "RFB Buffer" );
-  CHECK_PTR( buffer_ );
-  decoder_->setBuffer( buffer_ );
+                buffer_ = new KRFBBuffer( decoder_, this, "RFB Buffer" );
+                CHECK_PTR( buffer_ );
+                decoder_->setBuffer( buffer_ );
 
-  connect( decoder_, SIGNAL( status( const QString & ) ),
-           this, SIGNAL( statusChanged( const QString & ) ) );
-  emit loggedIn();
+                connect( decoder_, SIGNAL( status( const QString & ) ),
+                                                this, SIGNAL( statusChanged( const QString & ) ) );
+                emit loggedIn();
 
-  decoder_->start();
+                decoder_->start();
 
-  updater = new QTimer;
-  connect( updater, SIGNAL( timeout() ), SLOT( updateTimer() ) );
-  updater->start( options_->updateRate );
+                updater = new QTimer;
+                connect( updater, SIGNAL( timeout() ), SLOT( updateTimer() ) );
+                updater->start( options_->updateRate );
 }
 
 void KRFBConnection::gotSocketError( int err )
 {
-  currentState_ = Error;
-
-  // Do some error handling stuff
-  qWarning( "KRFBConnection: Socket error %d", err );
-
-  static QString refused = tr( "Connection Refused" );
-  static QString host = tr( "Host not found" );
-  static QString read = tr( "Read Error: QSocket reported an error reading\n"
-                              "data, the remote host has probably dropped the\n"
-                              "connection." );
-  static QString confused = tr( "QSocket reported an invalid error code" );
-
-  QString msg;
-  switch ( err ) {
-  case QSocket::ErrConnectionRefused:
-    msg = refused;
-    break;
-  case QSocket::ErrHostNotFound:
-    msg = host;
-    break;
-  case QSocket::ErrSocketRead:
-    msg = read;
-    break;
-  default:
-    msg = confused;
-  };
-
-  QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
-  delete sock;
-  sock = 0;
-  currentState_ = Disconnected;
-
-  emit error( msg );
+                currentState_ = Error;
+
+                // Do some error handling stuff
+                qWarning( "KRFBConnection: Socket error %d", err );
+
+                static QString refused = tr( "Connection Refused" );
+                static QString host = tr( "Host not found" );
+                static QString read = tr( "Read Error: QSocket reported an error reading\n"
+                                                "data, the remote host has probably dropped the\n"
+                                                "connection." );
+                static QString confused = tr( "QSocket reported an invalid error code" );
+
+                QString msg;
+                switch ( err ) {
+                                case QSocket::ErrConnectionRefused:
+                                                msg = refused;
+                                                break;
+                                case QSocket::ErrHostNotFound:
+                                                msg = host;
+                                                break;
+                                case QSocket::ErrSocketRead:
+                                                msg = read;
+                                                break;
+                                default:
+                                                msg = confused;
+                };
+
+                QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
+                delete sock;
+                sock = 0;
+                currentState_ = Disconnected;
+
+                emit error( msg );
 }
 
 void KRFBConnection::gotMoreData()
 {
-  assert( minData_ > 0 );
+                assert( minData_ > 0 );
 
-  if ( sock->size() >= minData_ ) {
-    minData_ = 0;
-    QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
-    emit gotEnoughData();
-  }
+                if ( sock->size() >= minData_ ) {
+                                minData_ = 0;
+                                QObject::disconnect( sock, SIGNAL( readyRead() ), this, SLOT( gotMoreData() ) );
+                                emit gotEnoughData();
+                }
 }
 
 void KRFBConnection::waitForData( unsigned int sz )
 {
-  assert( minData_ == 0 );
-  assert( sz > 0 );
-  assert( currentState_ != Error );
-   
-  if ( sock->size() >= sz ) {
-      //    qWarning( "No need to wait for data" );
-    emit gotEnoughData();
-  }
-  else {
-      //    qWarning( "Waiting for %u bytes", sz );
-    
-    minData_ = sz;
-    connect( sock, SIGNAL( readyRead() ), SLOT( gotMoreData() ) );
-  }
+                assert( minData_ == 0 );
+                assert( sz > 0 );
+                assert( currentState_ != Error );
+
+                if ( sock->size() >= sz ) {
+                                //    qWarning( "No need to wait for data" );
+                                emit gotEnoughData();
+                }
+                else {
+                                //    qWarning( "Waiting for %u bytes", sz );
+                                minData_ = sz;
+                                connect( sock, SIGNAL( readyRead() ), SLOT( gotMoreData() ) );
+                }
 }
 
 int KRFBConnection::read( void *buf, int sz )
 {
-  return sock->readBlock( (char *)  buf, sz );
+                return sock->readBlock( (char *)  buf, sz );
 }
 
 int KRFBConnection::write( void *buf, int sz )
 {
-  return sock->writeBlock( (const char *) buf, sz );
+                return sock->writeBlock( (const char *) buf, sz );
 }
 
 KRFBConnection::State KRFBConnection::state() const
 {
-  return currentState_;
+                return currentState_;
 }
 
 void KRFBConnection::setPortBase( int base )
 {
-  portBase_ = base;
+                portBase_ = base;
 }
 
 int KRFBConnection::portBase() const
 {
-  return portBase_;
-}
-
-void KRFBConnection::setPassword( const QCString &pass )
-{
-  this->pass_ = pass;
+                return portBase_;
 }
 
 void KRFBConnection::updateTimer()
 {
-  decoder_->sendUpdateRequest( true );
+                decoder_->sendUpdateRequest( true );
 }
 
 void KRFBConnection::refresh()
 {
-  decoder_->sendUpdateRequest( false );
+                decoder_->sendUpdateRequest( false );
 }
 
 void KRFBConnection::sendCutText( const QString &text )
 {
-  decoder_->sendCutEvent( text );
+                decoder_->sendCutEvent( text );
 }
 
 const QUrl &KRFBConnection::url()
 {
-  url_.setProtocol( "vnc" );
-  url_.setPort( display() );
-  url_.setHost( host() );
-  url_.setPath( "/" );
+                url_.setProtocol( "vnc" );
+                url_.setPort( display() );
+                url_.setHost( host() );
+                url_.setPath( "/" );
 
-  return url_;
+                return url_;
 }
diff --git a/noncore/comm/keypebble/krfbconnection.h b/noncore/comm/keypebble/krfbconnection.h
index fe477c1..a8d3457 100644
--- a/noncore/comm/keypebble/krfbconnection.h
+++ b/noncore/comm/keypebble/krfbconnection.h
@@ -1,152 +1,147 @@
 // -*- c++ -*-
 
 #ifndef KRFBCONNECTION_H
 #define KRFBCONNECTION_H
 
 #include <qobject.h>
 #include <qstring.h>
 #include <qcstring.h>
+#include "krfbserver.h"
 #include <qurl.h>
 
 class KRFBLogin;
 class KRBUpdateHandler;
-class KRFBOptions;
+class KRFBServer;
 class QSocket;
 class KRFBDecoder;
 class KRFBBuffer;
 class QTimer;
 
 /**
  * Encapsulates the RFB socket.
  *
  */
 class KRFBConnection : public QObject
 {
   Q_OBJECT
 
 public:
   friend class KRFBLogin;
   friend class KRFBDecoder;
 
   //* The state of the connection.
   enum State {
     Connecting,
     LoggingIn,
     Connected,
     Disconnecting,
     Disconnected,
     Error
   };
 
   KRFBConnection( QObject *parent = 0 );
   ~KRFBConnection();
 
   //* Get the state of a connection.
   State state() const;
 
   //* Get the options for this connection
-  KRFBOptions *options() const { return options_; };
+  KRFBServer *options() const { return options_; };
 
   KRFBBuffer *buffer() const { return buffer_; };
 
   KRFBDecoder *decoder() const { return decoder_; };
 
   //* Set the base from which the port for a given display will be calculated.
   void setPortBase( int base );
 
   //* Get the base from which the port for a given display is calculated.
   int portBase() const;
 
-  //* Set the password which will be used to login
-  void setPassword( const QCString &pass );
-
   //* Open a connection
-  void connectTo( const QCString &host, int display );
+  void connectTo( KRFBServer);
 
   //* Close the connection
   void disconnect();
 
   //* Get the host
-  const QCString host() const { return host_; };
+  const QCString host() const { return options_->hostname.latin1(); };
 
   //* Get the display
-  int display() const { return display_; };
+  int display() const { return options_->display; };
 
   //* Get the current host/display as a URL
   const QUrl &url();
 
   //* Reload the display
   void refresh();
 
   //* Send text to the remote clipboard
   void sendCutText( const QString & );
 
 protected slots:
   //* When the shit hits the fan
   void gotSocketError( int );
 
   //* When we have an open socket
   void gotSocketConnection();
 
   //* When we have logged in
   void gotRFBConnection();
 
   //* When some more data arrived
   void gotMoreData();
 
   void updateTimer();
 
   void disconnectDone();
 
 signals:
   //* Emitted when the status of the connection changes.
   void statusChanged( const QString & );
 
   /**
    * Emitted when we *really* need a password. If the password
    * was specified before you tried to connect then you won't
    * see this.
    */
   void passwordRequired( KRFBConnection * );
 
   //* When we have a working RFB connection
   void connected();
 
   void loggedIn();
 
   void disconnected();
 
   //* What happened?
   void error( const QString &msg );
 
   //* Emitted in response to a waitForData() call.
   void gotEnoughData();
 
 private:
   //
   // The following are called by our friends.
   //
 
   void waitForData( unsigned int );
 
   int read( void *buf, int sz );
   int write( void *buf, int sz );
 
 private:
-  QCString host_;
   int portBase_;
-  int display_;
-  QCString pass_;
   QSocket *sock;
   State currentState_;
   unsigned int minData_;
   QTimer *updater;
   KRFBLogin *login;
   KRFBDecoder *decoder_;
-  KRFBOptions *options_;
+  KRFBServer *options_;
   KRFBBuffer *buffer_;
   QUrl url_;
 };
 
 #endif // KRFBCONNECTION_H
 
diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp
index 174dd7b..a964c09 100644
--- a/noncore/comm/keypebble/krfbdecoder.cpp
+++ b/noncore/comm/keypebble/krfbdecoder.cpp
@@ -1,386 +1,386 @@
 #include "krfbconnection.h"
-#include "krfboptions.h"
+#include "krfbserver.h"
 #include "krfbserverinfo.h"
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 
 #include <qpe/qpeapplication.h>
 
 #include <qpixmap.h>
 #include <qsocket.h>
 #include <qevent.h>
 #include <qstring.h>
 #include <qclipboard.h>
 
 #include <assert.h>
 
 //
 // Endian stuff
 //
 #ifndef KDE_USE_FINAL
 const int endianTest = 1;
 #endif
 
 #define Swap16IfLE(s) \
     (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))
 
 #define Swap32IfLE(l) \
     (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \
                              (((l) & 0x00ff0000) >> 8)  | \
                              (((l) & 0x0000ff00) << 8)  | \
                              (((l) & 0x000000ff) << 24))  : (l))
 
 //
 // The lengths of the messages we need to wait for
 //
 const int ServerInitLength = 24;
 const int UpdateHeaderLength = 4;
 const int RectHeaderLength = 12;
 const int RectChunkSize = 4;
 const int CopyRectPosLength = 4;
 const int ServerCutLenLength = 7;
 
 //
 // Client -> Server Message Identifiers
 //
 static CARD8 SetPixelFormatId = 0;
 //static CARD8 FixColourMapEntriesId = 1; // Not used
 static CARD8 SetEncodingsId = 2;
 static CARD8 UpdateRequestId = 3;
 static CARD8 KeyEventId = 4;
 static CARD8 PointerEventId = 5;
 static CARD8 ClientCutTextId = 6;
 
 //
 // Server -> Client Message Identifiers
 //
 static CARD8 UpdateId = 0;
 static CARD8 BellId = 2;
 static CARD8 ServerCutId = 3;
 
 //
 // Encoding identifiers
 //
 static CARD32 RawEncoding = Swap32IfLE( 0 );
 static CARD32 CopyRectEncoding = Swap32IfLE(1 );
 static CARD32 RreEncoding = Swap32IfLE( 2 );
 static CARD32 CorreEncoding = Swap32IfLE( 4 );
 static CARD32 HexTileEncoding = Swap32IfLE( 5 );
 
 static struct {
     int keysym;
     int keycode;
 } keyMap[] = {
     { 0xff08, Qt::Key_Backspace },
     { 0xff09, Qt::Key_Tab       },
     { 0xff0d, Qt::Key_Return    },
     { 0xff1b, Qt::Key_Escape    },
     { 0xff63, Qt::Key_Insert    },
     { 0xffff, Qt::Key_Delete    },
     { 0xff50, Qt::Key_Home      },
     { 0xff57, Qt::Key_End       },
     { 0xff55, Qt::Key_Prior     },
     { 0xff56, Qt::Key_Next      },
     { 0xff51, Qt::Key_Left      },
     { 0xff52, Qt::Key_Up        },
     { 0xff53, Qt::Key_Right     },
     { 0xff54, Qt::Key_Down      },
     { 0xffbe, Qt::Key_F1        },
     { 0xffbf, Qt::Key_F2        },
     { 0xffc0, Qt::Key_F3        },
     { 0xffc1, Qt::Key_F4        },
     { 0xffc2, Qt::Key_F5        },
     { 0xffc3, Qt::Key_F6        },
     { 0xffc4, Qt::Key_F7        },
     { 0xffc5, Qt::Key_F8        },
     { 0xffc6, Qt::Key_F9        },
     { 0xffc7, Qt::Key_F10       },
     { 0xffc8, Qt::Key_F11       },
     { 0xffc9, Qt::Key_F12       },
     { 0xffe1, Qt::Key_Shift     },
     { 0xffe2, Qt::Key_Shift     },
     { 0xffe3, Qt::Key_Control   },
     { 0xffe4, Qt::Key_Control   },
     { 0xffe7, Qt::Key_Meta      },
     { 0xffe8, Qt::Key_Meta      },
     { 0xffe9, Qt::Key_Alt       },
     { 0xffea, Qt::Key_Alt       },
     { 0, 0 }
 };
 
 
 KRFBDecoder::KRFBDecoder( KRFBConnection *con )
   : QObject( con, "RFB Decoder" )
 {
   assert( con );
   assert( con->state() == KRFBConnection::Connected );
 
   this->con = con;
   this->buf = 0;
   this->info = 0;
   this->format = 0;
   this->buttonMask = 0;
   currentState = Idle;
 }
 
 KRFBDecoder::~KRFBDecoder()
 {
   if ( info )
     delete info;
   if ( format )
     delete format;
 }
 
 void KRFBDecoder::start()
 {
   sendClientInit();
 }
 
 void KRFBDecoder::sendClientInit()
 {
   con->write( &( con->options()->shared ), 1 );
 
   // Wait for server init
   qWarning( "Waiting for server init" );
 
   static QString statusMsg = tr( "Waiting for server initialisation..." );
   emit status( statusMsg );
 
   currentState = AwaitingServerInit;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerInit() ) );
   con->waitForData( ServerInitLength );
 }
 
 void KRFBDecoder::gotServerInit()
 {
   qWarning( "Got server init" );
   disconnect( con, SIGNAL( gotEnoughData() ), this, SLOT( gotServerInit() ) );
 
   if ( info )
     delete info;
   info = new KRFBServerInfo;
   CHECK_PTR( info );
 
   con->read( &(info->width), 2 );
   info->width = Swap16IfLE( info->width );
   con->read( &info->height, 2 );
   info->height = Swap16IfLE( info->height );
 
   con->read( &(info->bpp), 1 );
   con->read( &(info->depth), 1 );
   con->read( &(info->bigEndian), 1 );
   con->read( &(info->trueColor), 1 );
 
   con->read( &(info->redMax), 2 );
   info->redMax = Swap16IfLE( info->redMax );
   con->read( &(info->greenMax), 2 );
   info->greenMax = Swap16IfLE( info->greenMax );
   con->read( &(info->blueMax), 2 );
   info->blueMax = Swap16IfLE( info->blueMax );
 
   con->read( &(info->redShift), 1 );
   con->read( &(info->greenShift), 1 );
   con->read( &(info->blueShift), 1 );
 
   con->read( info->padding, 3 );
 
   con->read( &(info->nameLength), 4 );
   info->nameLength = Swap32IfLE( info->nameLength );
 
   qWarning( "Width = %d, Height = %d", info->width, info->height );
   qWarning( "Bpp = %d, Depth = %d, Big = %d, True = %d",
            info->bpp, info->depth, info->bigEndian, info->trueColor );
   qWarning( "RedMax = %d, GreenMax = %d, BlueMax = %d",
            info->redMax, info->greenMax, info->blueMax );
   qWarning( "RedShift = %d, GreenShift = %d, BlueShift = %d",
            info->redShift, info->greenShift,info-> blueShift );
 
   buf->resize( info->width, info->height );
 
   // Wait for desktop name
   qWarning( "Waiting for desktop name" );
 
   static QString statusMsg = tr( "Waiting for desktop name..." );
   emit status( statusMsg );
 
   currentState = AwaitingDesktopName;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotDesktopName() ) );
   con->waitForData( info->nameLength );
 }
 
 void KRFBDecoder::gotDesktopName()
 {
   assert( info );
   assert( currentState == AwaitingDesktopName );
 
   qWarning( "Got desktop name" );
 
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotDesktopName() ) );
 
   char *buf = new char[ info->nameLength + 1 ];
   CHECK_PTR( buf );
 
   con->read( buf, info->nameLength );
   buf[ info->nameLength ] = '\0';
   info->name = buf;
 
   qWarning( "Desktop: %s", info->name.latin1() );
 
   delete buf;
 
   // Get the format we'll really use and tell the server
   decidePixelFormat();
   sendPixelFormat();
   sendAllowedEncodings();
   currentState = Idle;
 
   QString msg;
   msg = tr( "Connected to %1" );
   msg = msg.arg( info->name );
   emit status( msg );
 
   sendUpdateRequest( false );
 }
 
 void KRFBDecoder::decidePixelFormat()
 {
   assert( info );
 
   if ( format )
     delete format;
   format = new KRFBPixelFormat;
   CHECK_PTR( format );
 
   // What depth do we want?
   //
   // We'll use the minimum of the remote and local depths, UNLESS an
   // eight bit session has been specifically requested by the user.
   int screenDepth = QPixmap::defaultDepth();
   int bestDepth = ( screenDepth > info->depth ) ? info->depth : screenDepth;
   int chosenDepth;
 
   if ( con->options()->colors256 )
     chosenDepth = 8;
   else
     chosenDepth = bestDepth;
 
   qWarning( "Screen depth=%d, server depth=%d, best depth=%d, " \
            "eight bit %d, chosenDepth=%d",
            screenDepth,
            info->depth,
            bestDepth, 
            con->options()->colors256, chosenDepth );
 
   format->depth = chosenDepth;
 
   // If we're using the servers native depth
   if ( chosenDepth == info->depth ) {
     // Use the servers native format
     format->bpp = info->bpp;
     //    format->bigEndian = info->bigEndian;
     format->bigEndian = true;
     format->trueColor = info->trueColor;
     format->redMax = info->redMax;
     format->greenMax = info->greenMax;
     format->blueMax = info->blueMax;
     format->redShift = info->redShift;
     format->greenShift = info->greenShift;
     format->blueShift = info->blueShift;
   }
   else {
     if ( chosenDepth == 8 ) {
       format->bpp = 8;
       format->bigEndian = true;
       format->trueColor = true;
       format->redMax = 7;
       format->greenMax = 7;
       format->blueMax = 3;
       format->redShift = 0;
       format->greenShift = 3;
       format->blueShift = 6;
     }
   }
 
   format->redMax = Swap16IfLE( format->redMax );
   format->greenMax = Swap16IfLE( format->greenMax );
   format->blueMax = Swap16IfLE( format->blueMax );
 }
 
 void KRFBDecoder::sendPixelFormat()
 {
   static char padding[3];
   con->write( &SetPixelFormatId, 1 );
   con->write( padding, 3 );
 
   con->write( &(format->bpp), 1 );
   con->write( &(format->depth), 1 );
   con->write( &(format->bigEndian), 1 );
   con->write( &(format->trueColor), 1 );
 
   con->write( &(format->redMax), 2 );
   con->write( &(format->greenMax), 2 );
   con->write( &(format->blueMax), 2 );
 
   con->write( &(format->redShift), 1 );
   con->write( &(format->greenShift), 1 );
   con->write( &(format->blueShift), 1 );
   con->write( format->padding, 3 ); // Padding
 }
 
 void KRFBDecoder::sendAllowedEncodings()
 {
   static CARD8 padding[1];
   con->write( &SetEncodingsId, 1 );
   con->write( padding, 1 );
 
   static CARD16 noEncodings = con->options()->encodings();
   noEncodings = Swap16IfLE( noEncodings );
   con->write( &noEncodings, 2 );
 
   if ( con->options()->corre )
     con->write( &CorreEncoding, 4 );
   if ( con->options()->hexTile )
     con->write( &HexTileEncoding, 4 );
   if ( con->options()->rre )
     con->write( &RreEncoding, 4 );
   if ( con->options()->copyrect )
     con->write( &CopyRectEncoding, 4 );
   // We always support this
   con->write( &RawEncoding, 4 );
 }
 
 void KRFBDecoder::sendUpdateRequest( bool incremental )
 {
   if ( currentState != Idle )
     return;
 
   con->write( &UpdateRequestId, 1 );
   con->write( &incremental, 1 );
 
   static CARD16 x = 0, y = 0;
   static CARD16 w = Swap16IfLE( info->width );
   static CARD16 h = Swap16IfLE( info->height );
 
   con->write( &x, 2 );
   con->write( &y, 2 );
   con->write( &w, 2 );
   con->write( &h, 2 );
 
   // Now wait for the update
   currentState = AwaitingUpdate;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
   con->waitForData( UpdateHeaderLength );
 }
 
 void KRFBDecoder::gotUpdateHeader()
 {
   assert( currentState == AwaitingUpdate );
 
   //  qWarning( "Got update header" );
 
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotUpdateHeader() ) );
 
   CARD8 msgType;
   con->read( &msgType, 1 );
@@ -415,425 +415,426 @@ void KRFBDecoder::gotUpdateHeader()
   //  qWarning( "Expecting %d rects", noRects );
 
   // Now wait for the data
   currentState = AwaitingRectHeader;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
   con->waitForData( RectHeaderLength );
 }
 
 void KRFBDecoder::gotRectHeader()
 {
   assert( currentState == AwaitingRectHeader );
 
   //  qWarning( "Got rect header" );
 
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotRectHeader() ) );
 
   con->read( &x, 2 );
   x = Swap16IfLE( x );
   con->read( &y, 2 );
   y = Swap16IfLE( y );
 
   con->read( &w, 2 );
   w = Swap16IfLE( w );
   con->read( &h, 2 );
   h = Swap16IfLE( h );
 
   con->read( &encoding, 4 );
 
   //  CARD32 encodingLocal = Swap32IfLE( encoding );
   //  qWarning( "Rect: x=%d, y= %d, w=%d, h=%d, encoding=%ld", 
           //   x, y, w, h, encodingLocal );
 
   //
   // Each encoding needs to be handled differently. Some require
   // waiting for more data, but others like a copyrect do not.
   // Our constants have already been byte swapped, so we use
   // the remote value as is.
   //
   if ( encoding == RawEncoding ) {
       //    qWarning( "Raw encoding" );
     handleRawRect();
   }
   else if ( encoding == CopyRectEncoding ) {
 //    qWarning( "CopyRect encoding" );
     handleCopyRect();
   }
   else if ( encoding == RreEncoding ) {
     qWarning( "RRE encoding" );
     handleRRERect();
   }
   else if ( encoding == CorreEncoding ) {
     qWarning( "CoRRE encoding" );
     handleCoRRERect();
   }
   else if ( encoding == HexTileEncoding ) {
     qWarning( "HexTile encoding" );
     handleHexTileRect();
   }
   else {
     int msg = Swap32IfLE( encoding );
     QString protocolError = tr( "Protocol Error: An unknown encoding was "
                                   "used by the server %1" ).arg( msg );
     currentState = Error;
     qWarning( "Unknown encoding, %d", msg );
     emit error( protocolError );
     return;
   }
 }
 
 //
 // Raw Encoding
 //
 
 void KRFBDecoder::handleRawRect()
 {
   // We need something a bit cleverer here to handle large
   // rectanges nicely. The chunking should be based on the
   // overall size (but has to be in complete lines).
 
     //  qWarning( "Handling a raw rect chunk" );
 
     //  CARD32 lineCount = w * format->bpp / 8;
 
   if ( h > RectChunkSize ) {
     //    if ( con->sock->size() / lineCount ) {
     //      getRawRectChunk( con->sock->size() / lineCount );
     //    }
     //    else {
       getRawRectChunk( RectChunkSize );
       //   }
   }
   else {
     getRawRectChunk( h );
   }
 }
 
 void KRFBDecoder::getRawRectChunk( int lines )
 {
   this->lines = lines;
   CARD32 count = lines * w * format->bpp / 8;
 
   // Wait for server init
   //  qWarning( "Waiting for raw rect chunk, %ld", count );
 
   currentState = AwaitingRawRectChunk;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRawRectChunk() ) );
   con->waitForData( count );
 }
 
 void KRFBDecoder::gotRawRectChunk()
 {
   assert( currentState == AwaitingRawRectChunk );
 
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotRawRectChunk() ) );
 
   //  qWarning( "Got raw rect chunk" );
 
   //
   // Read the rect data and copy it to the buffer.
   //
   
   // TODO: Replace this!
   int count = lines * w * format->bpp / 8;
   char *hack = new char[ count ];
   con->read( hack, count );
   buf->drawRawRectChunk( hack, x, y, w, lines );
   delete hack;
   // /TODO:
 
   h = h - lines;
   y = y + lines;
 
   if ( h > 0 ) {
     handleRawRect();
   }
   else {
     noRects--;
 
     //    qWarning( "There are %d rects left", noRects );
 
     if ( noRects ) {
       currentState = AwaitingRectHeader;
       connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
       con->waitForData( RectHeaderLength );
     }
     else
       currentState = Idle;
   }
 }
 
 //
 // Copy Rectangle Encoding
 //
 
 void KRFBDecoder::handleCopyRect()
 {
   currentState = AwaitingCopyRectPos;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotCopyRectPos() ) );
   con->waitForData( CopyRectPosLength );
 }
 
 void KRFBDecoder::gotCopyRectPos()
 {
   disconnect( con, SIGNAL( gotEnoughData() ),
               this, SLOT( gotCopyRectPos() ) );
 
   CARD16 srcX;
   CARD16 srcY;
 
   con->read( &srcX, 2 );
   con->read( &srcY, 2 );
 
   srcX = Swap16IfLE( srcX );
   srcY = Swap16IfLE( srcY );
 
   buf->copyRect( srcX, srcY, x, y, w, h );
 
   noRects--;
 
   //    qWarning( "There are %d rects left", noRects );
 
   if ( noRects ) {
     currentState = AwaitingRectHeader;
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
     con->waitForData( RectHeaderLength );
   }
   else
     currentState = Idle;
 }
 
 void KRFBDecoder::handleRRERect()
 {
   qWarning( "RRE not implemented" );
 }
 
 void KRFBDecoder::handleCoRRERect()
 {
   qWarning( "CoRRE not implemented" );
 }
 
 void KRFBDecoder::handleHexTileRect()
 {
   qWarning( "HexTile not implemented" );
 }
 
 void KRFBDecoder::sendMouseEvent( QMouseEvent *e )
 {
   // Deal with the buttons
   if ( e->type() != QEvent::MouseMove ) {
     buttonMask = 0;
     if ( e->type() == QEvent::MouseButtonPress ) {
       if ( e->button() & LeftButton )
         buttonMask |= 0x01;
       if ( e->button() & MidButton )
         buttonMask |= 0x04;
       if ( e->button() & RightButton )
         buttonMask |= 0x02;
     }
     else if ( e->type() == QEvent::MouseButtonRelease ) {
       if ( e->button() & LeftButton )
         buttonMask &= 0x06;
       if ( e->button() & MidButton )
         buttonMask |= 0x03;
       if ( e->button() & RightButton )
         buttonMask |= 0x05;
     }
   }
 
   CARD16 x = Swap16IfLE( e->x() );
   CARD16 y = Swap16IfLE( e->y() );
 
   con->write( &PointerEventId, 1 );
   con->write( &buttonMask, 1 );
   con->write( &x, 2 );
   con->write( &y, 2 );
 }
 
 
 void KRFBDecoder::sendCutEvent( const QString &unicode )
 {
   //
   // Warning: There is a bug in the RFB protocol because there is no way to find
   // out the codepage in use on the remote machine. This could be fixed by requiring
   // the remote server to use utf8 etc. but for now we have to assume they're the
   // same. I've reported this problem to the ORL guys, but they apparantly have no
   // immediate plans to fix the issue. :-( (rich)
   //
 
   CARD8 padding[3];
   QCString text = unicode.local8Bit();
   CARD32 length = text.length();
   length = Swap32IfLE( length );
 
   con->write( &ClientCutTextId, 1 );
   con->write( &padding, 3 );
   con->write( &length, 4 );
   con->write( text.data(), length );
 }
 
 void KRFBDecoder::gotServerCut()
 {
   qWarning( "Got server cut" );
 
   currentState = AwaitingServerCutLength;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutLength() ) );
   con->waitForData( ServerCutLenLength );
 }
 
 void KRFBDecoder::gotServerCutLength()
 {
   assert( currentState = AwaitingServerCutLength );
   disconnect( con, SIGNAL( gotEnoughData() ),
               this, SLOT( gotServerCutLength() ) );
 
   CARD8 padding[3];
   con->read( padding, 3 );
 
   con->read( &serverCutTextLen, 4 );
   serverCutTextLen = Swap32IfLE( serverCutTextLen );
 
   currentState = AwaitingServerCutText;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutText() ) );
   con->waitForData( serverCutTextLen );
 }
 
 void KRFBDecoder::gotServerCutText()
 {
   assert( currentState = AwaitingServerCutText );
 
   disconnect( con, SIGNAL( gotEnoughData() ),
               this, SLOT( gotServerCutText() ) );
 
   //
   // Warning: There is a bug in the RFB protocol because there is no way to find
   // out the codepage in use on the remote machine. This could be fixed by requiring
   // the remote server to use utf8 etc. but for now we have to assume they're the
   // same. I've reported this problem to the ORL guys, but they apparantly have no
   // immediate plans to fix the issue. :-( (rich)
   //
 
   char *cutbuf = new char[ serverCutTextLen + 1 ];
   CHECK_PTR( cutbuf );
 
   con->read( cutbuf, serverCutTextLen );
   cutbuf[ serverCutTextLen ] = '\0';
 
   qWarning( "Server cut: %s", cutbuf );
 
   QString cutText( cutbuf ); // DANGER!!
   qApp->clipboard()->setText( cutText );
 
   delete cutbuf;
 
   // Now wait for the update (again)
   if ( oldState == AwaitingUpdate ) {
     currentState = AwaitingUpdate;
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
     con->waitForData( UpdateHeaderLength );
   }
   else if ( oldState == Idle ) {
     currentState = Idle;
   }
   else {
     qWarning( "Async handled in weird state" );
     currentState = oldState;
   };
 }
 
 void KRFBDecoder::gotBell()
 {
   qWarning( "Got server bell" );
   buf->soundBell();
 
   // Now wait for the update (again)
   if ( oldState == AwaitingUpdate ) {
     currentState = AwaitingUpdate;
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotUpdateHeader() ) );
     con->waitForData( UpdateHeaderLength );
   }
   else if ( oldState == Idle ) {
     currentState = Idle;
   }
   else {
     qWarning( "Async handled in weird state" );
     currentState = oldState;
   };
 }
 
 void KRFBDecoder::sendKeyPressEvent( QKeyEvent *event )
 {
   int key;
   key = toKeySym( event );
   if ( key ) {
     key = Swap32IfLE( key );
 
     CARD8 mask = true;
 
     CARD16 padding = 0;
     con->write( &KeyEventId, 1 );
     con->write( &mask, 1 );
     con->write( &padding, 2 );
     con->write( &key, 4 );
   }
 }
 
 void KRFBDecoder::sendKeyReleaseEvent( QKeyEvent *event )
 {
   int key;
   key = toKeySym( event );
   if ( key ) {
     key = Swap32IfLE( key );
 
     CARD8 mask = false;
 
     CARD16 padding = 0;
     con->write( &KeyEventId, 1 );
     con->write( &mask, 1 );
     con->write( &padding, 2 );
     con->write( &key, 4 );
   }
 }
 
+
 int KRFBDecoder::toKeySym( QKeyEvent *k )
 {
   int ke = 0;
 
   ke = k->ascii();
   // Markus: Crappy hack. I dont know why lower case letters are
   // not defined in qkeydefs.h. The key() for e.g. 'l' == 'L'. 
   // This sucks. :-(
 
   if ( (ke == 'a') || (ke == 'b') || (ke == 'c') || (ke == 'd') 
        || (ke == 'e') || (ke == 'f') || (ke == 'g') || (ke == 'h')
        || (ke == 'i') || (ke == 'j') || (ke == 'k') || (ke == 'l')
        || (ke == 'm') || (ke == 'n') || (ke == 'o') || (ke == 'p')
        || (ke == 'q') || (ke == 'r') || (ke == 's') || (ke == 't')
        || (ke == 'u') || (ke == 'v') ||( ke == 'w') || (ke == 'x')
        || (ke == 'y') || (ke == 'z') ) {
     ke = k->key();
     ke = ke + 0x20;
     return ke;
   }
 
   // qkeydefs = xkeydefs! :-)
   if ( ( k->key() >= 0x0a0 ) && k->key() <= 0x0ff )
       return k->key();
 
   if ( ( k->key() >= 0x20 ) && ( k->key() <= 0x7e ) )
     return k->key();
   
   // qkeydefs != xkeydefs! :-(
   // This is gonna suck :-(
 
   int i = 0;
   while ( keyMap[i].keycode ) {
     if ( k->key() == keyMap[i].keycode )
         return keyMap[i].keysym;
     i++;
   }
 
   return 0;
 }
 
diff --git a/noncore/comm/keypebble/krfblogin.cpp b/noncore/comm/keypebble/krfblogin.cpp
index cc3a8fa..0d2a205 100644
--- a/noncore/comm/keypebble/krfblogin.cpp
+++ b/noncore/comm/keypebble/krfblogin.cpp
@@ -1,256 +1,254 @@
 #include <assert.h>
 
 
 extern "C" {
 #include "vncauth.h"
 }
 
 #include "krfblogin.h"
 #include "krfbconnection.h"
 #include <qtimer.h>
 #include <qregexp.h>
 
 // The length of the various messages (used to decide how many bytes to
 // wait for).
 const int ServerVersionLength = 12;
 const int ClientVersionLength = 12;
 const int AuthSchemeLength = 4;
 const int FailureReasonSizeLength = 4;
 const int ChallengeLength = 16;
 const int AuthResultLength = 4;
 
 // Authentication results
 enum AuthResult {
   AuthOk,
   AuthFailed,
   AuthTooMany
 };
 
 typedef unsigned char CARD8;
 typedef unsigned short CARD16;
 typedef unsigned long CARD32;
 
 const int endianTest = 1;
 
 // Endian stuff
 #define Swap16IfLE(s) \
     (*(char *)&endianTest ? ((((s) & 0xff) << 8) | (((s) >> 8) & 0xff)) : (s))
 
 #define Swap32IfLE(l) \
     (*(char *)&endianTest ? ((((l) & 0xff000000) >> 24) | \
                              (((l) & 0x00ff0000) >> 8)  | \
                              (((l) & 0x0000ff00) << 8)  | \
                              (((l) & 0x000000ff) << 24))  : (l))
 
 KRFBLogin::KRFBLogin( KRFBConnection *con )
   : QObject( con, "RFB login manager" )
 {
   assert( con );
   this->con = con;
   currentState = AwaitingServerVersion;
 
   connect( this, SIGNAL( error( const QString & ) ),
            con, SIGNAL( error( const QString & ) ) );
 
-  connect( this, SIGNAL( passwordRequired( KRFBConnection * ) ),
-           con, SIGNAL( passwordRequired( KRFBConnection * ) ) );
 
   qWarning( "Waiting for server version..." );
 
   static QString statusMsg = tr( "Waiting for server version..." );
   emit status( statusMsg );
 
   // Kick off the state machine
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerVersion() ) );
   con->waitForData( ServerVersionLength );
 }
 
 KRFBLogin::~KRFBLogin()
 {
 
 }
 
 KRFBLogin::State KRFBLogin::state() const
 {
   return currentState;
 }
 
 void KRFBLogin::gotServerVersion()
 {
   qWarning( "Got server version" );
 
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotServerVersion() ) );
 
   // Read the server's version message
   char serverVersion[ ServerVersionLength + 1 ];
   con->read( serverVersion, ServerVersionLength );
   serverVersion[ ServerVersionLength ] = '\0';
 
   QCString rfbString( serverVersion, ServerVersionLength + 1 );
   versionString = rfbString;
 
   QRegExp regexp( "RFB [0-9][0-9][0-9]\\.[0-9][0-9][0-9]\n" );
 
   if ( rfbString.find( regexp ) == -1 ) {
     static QString msg = tr( "Error: Invalid server version, %1" ).arg( rfbString );
 
     qWarning( msg );
     emit error( msg );
     currentState = Error;
     return;
   }
 
   // Calculate the actual version number
   serverMajor = (serverVersion[4] - '0') * 100
     + (serverVersion[5] - '0') * 10
     + (serverVersion[6] - '0');
   serverMinor = (serverVersion[8] - '0') * 100
     + (serverVersion[9] - '0') * 10
     + (serverVersion[10] - '0');
 
   qWarning("Server Version: %03d.%03d", serverMajor, serverMinor );
 
   if ( serverMajor != 3 ) {
     QString msg = tr( "Error: Unsupported server version, %1" )
       .arg( rfbString );
 
     qWarning( msg );
     emit error( msg );
     currentState = Error;
     return;    
   }
   
   if ( serverMinor != 3 ) {
     qWarning( "Minor version mismatch: %d", serverMinor );
   }
 
   // Setup for the next state
   sendClientVersion();
 
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotAuthScheme() ) );
   con->waitForData( AuthSchemeLength );
 }
 
 void KRFBLogin::gotAuthScheme()
 {
   disconnect( con, SIGNAL( gotEnoughData() ), 
               this, SLOT( gotAuthScheme() ) );
 
   // Got data
   CARD32 scheme;
   con->read( &scheme, AuthSchemeLength );
   scheme = Swap32IfLE( scheme );
 
   static QString statusMsgOk = tr( "Logged in" );
 
   switch ( scheme ) {
   case 0:
     qWarning( "Failed" );
     // Handle failure
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotFailureReasonSize() ) );
     con->waitForData( FailureReasonSizeLength );
     break;
   case 1:
     // Handle no auth
     emit status( statusMsgOk );
     con->gotRFBConnection();
     break;
   case 2:
     // Handle VNC auth
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotChallenge() ) );
     con->waitForData( ChallengeLength );
     break;
   default:
     qWarning( "Unknown authentication scheme, 0x%08lx", scheme );
     currentState = Error;
     break;
   };
 }
 
 void KRFBLogin::gotChallenge()
 {
   disconnect( con, SIGNAL( gotEnoughData() ),
               this, SLOT( gotChallenge() ) );
 
   QTimer::singleShot( 0, this, SLOT(getPassword()) );
 }
 
 void KRFBLogin::getPassword()
 {
   // Got data
   CARD8 challenge[ ChallengeLength ];
   con->read( challenge, ChallengeLength );
 
   // Last chance to enter a password
-  if ( con->pass_.isNull() ) {
+  if ( con->options_->password.isNull() ) {
     qWarning( "krfblogin needs a password" );
     emit passwordRequired( con );
   }
 
-  if ( con->pass_.isNull() ) {
+  if ( con->options_->password.isNull() ) {
     QString msg = tr( "Error: This server requires a password, but none "
                         "has been specified.\n" );
     
     emit error( msg );
     return;
   }
 
-  vncEncryptBytes( (unsigned char *) challenge, con->pass_.data() );
+  vncEncryptBytes( (unsigned char *) challenge, QCString(con->options_->password.latin1()).data() );
   con->write( challenge, ChallengeLength );
 
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotAuthResult() ) );
   con->waitForData( AuthResultLength );
 }
 
 void KRFBLogin::gotFailureReasonSize()
 {
   disconnect( con, SIGNAL( gotEnoughData() ), this,
               SLOT( gotFailureReasonSize() ) );
 }
 
 void KRFBLogin::gotAuthResult()
 {
   // Got data
   disconnect( con, SIGNAL( gotEnoughData() ), this,
               SLOT( gotAuthResult() ) );
 
   long result;
   con->read( &result, AuthResultLength );
   result = Swap32IfLE( result );
 
   qWarning( "Authentication Result is 0x%08lx", result );
 
   static QString failed = tr( "Error: The password you specified was incorrect." );
   static QString tooMany = tr( "Error: Too many invalid login attempts have been made\n"
                                  "to this account, please try later." );
 
   static QString statusMsgOk = tr( "Logged in" );
   static QString statusMsgFailed = tr( "Login Failed" );
   static QString statusMsgTooMany = tr( "Too many failures" );
 
   switch( result ) {
   case AuthOk:
     emit status( statusMsgOk );
     con->gotRFBConnection();
     break;
   case AuthFailed:
     qWarning( "Dammit" );
     emit status( statusMsgFailed );
     emit error( failed );
     break;
   case AuthTooMany:
     emit status( statusMsgTooMany );
     emit error( tooMany );    
     break;
   default:
     qWarning( "Invalid authentication result, %lx", result );
     break;
   }
 }
 
 void KRFBLogin::sendClientVersion()
 {
   qWarning( "Sending client version" );
   con->write( (void*)"RFB 003.003\n", ClientVersionLength );
 }
diff --git a/noncore/comm/keypebble/krfboptions.cpp b/noncore/comm/keypebble/krfboptions.cpp
deleted file mode 100644
index 8c4320b..0000000
--- a/noncore/comm/keypebble/krfboptions.cpp
+++ b/dev/null
@@ -1,56 +0,0 @@
-#include <qpe/config.h>
-#include <qpe/qpeapplication.h>
-#include "krfboptions.h"
-
-KRFBOptions::KRFBOptions()
-{
-  readSettings();
-}
-
-KRFBOptions::~KRFBOptions()
-{
-  writeSettings();
-}
-
-void KRFBOptions::readSettings()
-{
-  Config config( "keypebble" );
-  config.setGroup("Settings");
-  hexTile = config.readBoolEntry( "HexTile", 0 );
-  corre = config.readBoolEntry( "CORRE", 0 );
-  rre = config.readBoolEntry( "RRE", 0 );
-  copyrect = config.readBoolEntry( "CopyRect", 1 );
-  colors256 = config.readBoolEntry( "Colors256", 0 );
-  shared = config.readBoolEntry( "Shared", 0 );
-  readOnly = config.readBoolEntry( "ReadOnly", 0 );
-  updateRate = config.readNumEntry( "UpdateRate", 50 );
-  deIconify = config.readBoolEntry( "DeIconify", 0 );
-}
-
-void KRFBOptions::writeSettings()
-{
-  Config config( "keypebble" );
-  config.setGroup("Settings");
-  config.writeEntry( "HexTile", hexTile );
-  config.writeEntry( "CORRE", corre );
-  config.writeEntry( "RRE", rre );
-  config.writeEntry( "CopyRect", copyrect );
-  config.writeEntry( "Colors256", colors256 );
-  config.writeEntry( "Shared", shared );
-  config.writeEntry( "ReadOnly", readOnly );
-  config.writeEntry( "UpdateRate", updateRate );
-  config.writeEntry( "DeIconify", deIconify );
-}
-
-int KRFBOptions::encodings()
-{
-  // Initially one because we always support raw encoding
-  int count = 1;
-
-  count += hexTile ? 1 : 0;
-  count += corre ? 1 : 0;
-  count += rre ? 1 : 0;
-  count += copyrect ? 1 : 0;
-
-  return count;
-}
diff --git a/noncore/comm/keypebble/krfboptions.h b/noncore/comm/keypebble/krfboptions.h
deleted file mode 100644
index fd2b65c..0000000
--- a/noncore/comm/keypebble/krfboptions.h
+++ b/dev/null
@@ -1,31 +0,0 @@
-// -*- c++ -*-
-
-#ifndef KRFBOPTIONS_H
-#define KRFBOPTIONS_H
-
-class Config;
-
-class KRFBOptions
-{
-public:
-  KRFBOptions();
-  ~KRFBOptions();
-
-  int encodings();
-  void readSettings();
-  void writeSettings();
-
-  bool hexTile;
-  bool corre;
-  bool rre;
-  bool copyrect;
-    
-  bool colors256;
-  bool shared;
-  bool readOnly;
-  bool deIconify;
-
-  int updateRate;
-};
-
-#endif // KRFBOPTIONS_H
diff --git a/noncore/comm/keypebble/krfbserver.cpp b/noncore/comm/keypebble/krfbserver.cpp
new file mode 100644
index 0000000..5775f09
--- a/dev/null
+++ b/noncore/comm/keypebble/krfbserver.cpp
@@ -0,0 +1,39 @@
+#include <qpe/config.h>
+#include <qpe/qpeapplication.h>
+#include "krfbserver.h"
+
+KRFBServer::KRFBServer()
+{
+        QString name;
+        QString hostname;
+        QString password;
+        display=0;
+
+  hexTile=0;
+  corre=0;
+  rre=0;
+  copyrect=1;
+    
+  colors256=1;
+  shared=0;
+  readOnly=0;
+  deIconify=0;
+
+  updateRate=0;
+}
+KRFBServer::~KRFBServer()
+{
+}
+
+int KRFBServer::encodings()
+{
+  // Initially one because we always support raw encoding
+  int count = 1;
+
+  count += hexTile ? 1 : 0;
+  count += corre ? 1 : 0;
+  count += rre ? 1 : 0;
+  count += copyrect ? 1 : 0;
+
+  return count;
+}
diff --git a/noncore/comm/keypebble/kvnc.cpp b/noncore/comm/keypebble/kvnc.cpp
index 43cffc5..aa46e2f 100644
--- a/noncore/comm/keypebble/kvnc.cpp
+++ b/noncore/comm/keypebble/kvnc.cpp
@@ -1,190 +1,272 @@
 #include <qiconset.h>
 #include <qdialog.h>
 #include <qpixmap.h>
 #include <qdom.h>
 #include <qaction.h>
 #include <qpe/qpemenubar.h>
 #include <qstatusbar.h>
 #include <qpopupmenu.h>
 #include <qpushbutton.h>
 #include <qpe/qpetoolbar.h>
 #include <qtimer.h>
 #include <qmessagebox.h>
+#include <qspinbox.h>
+#include <qlistbox.h>
+#include <qlineedit.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/global.h>
+#include <qpe/qpetoolbar.h>
+#include <qpe/resource.h>
+
 #include <assert.h>
 
 #include "kvnc.h"
 #include "krfbcanvas.h"
-#include "kvncoptionsdlg.h"
 #include "krfbconnection.h"
+#include "kvncconndlg.h"
+#include "krfbserver.h"
+
+static int u_id = 1;
+static int get_unique_id() 
+{   
+                return u_id++;
+}
 
 
 /* XPM */
 static char * menu_xpm[] = {
 "12 12 5 1",
         " c None",
         ".c #000000",
         "+c #FFFDAD",
         "@c #FFFF00",
         "#c #E5E100",
 "            ",
 "            ",
 "  ......... ",
 "  .+++++++. ",
 "  .+@@@@#.  ",
 "  .+@@@#.   ",
 "  .+@@#.    ",
 "  .+@#.     ",
 "  .+#.      ",
 "  .+.       ",
 "  ..        ",
 "            "};
 
 const int StatusTextId = 0;
 
 KVNC::KVNC( const char *name ) : QMainWindow( 0, name )
 {
     setCaption( tr("VNC Viewer") );
     fullscreen = false;
 
-    canvas = new KRFBCanvas( this, "canvas" );
-    setCentralWidget( canvas );
+                stack = new QWidgetStack( this );
+                setCentralWidget( stack );
 
+                bookmarkSelector=new KVNCBookmarkDlg();
+                stack->addWidget(bookmarkSelector,get_unique_id());
+                stack->raiseWidget( bookmarkSelector );                                        
+
+                canvas = new KRFBCanvas( stack, "canvas" );
+                stack->addWidget(canvas,get_unique_id());
+    setCentralWidget( stack );
+
+    connect( bookmarkSelector->bookmarkList, SIGNAL(doubleClicked(QListBoxItem *)),
+            this, SLOT(openConnection(QListBoxItem *)) );
     connect( canvas->connection(), SIGNAL(statusChanged(const QString &)),
             this, SLOT(statusMessage(const QString &)) );
     connect( canvas->connection(), SIGNAL(error(const QString &)),
             this, SLOT(error(const QString &)) );
     connect( canvas->connection(), SIGNAL(connected()), this, SLOT(connected()) );
     connect( canvas->connection(), SIGNAL(loggedIn()), this, SLOT(loggedIn()) );
     connect( canvas->connection(), SIGNAL(disconnected()), this, SLOT(disconnected()) );
 
     setupActions();
 
     cornerButton = new QPushButton( this );
     cornerButton->setPixmap( QPixmap( (const char**)menu_xpm ) );
     connect( cornerButton, SIGNAL(pressed()), this, SLOT(showMenu()) );
     canvas->setCornerWidget( cornerButton );
 
-    QTimer::singleShot( 0, canvas, SLOT(openConnection()) );
+                stack->raiseWidget( bookmarkSelector );
+
+
+                QPEToolBar *bar = new QPEToolBar( this );
+
+                 QAction *n = new QAction( tr( "New Connection" ), Resource::loadPixmap( "new" ),
+                                QString::null, 0, this, 0 );
+                 connect( n, SIGNAL( activated() ),
+                                                this, SLOT( newConnection() ) );
+                n->addTo( bar );
+                                                                     
+                 QAction *o = new QAction( tr( "Open Bookmark" ), Resource::loadPixmap( "edit" ),
+                                QString::null, 0, this, 0 );
+                 connect( o, SIGNAL( activated() ),
+                                                this, SLOT( openConnection() ) );
+                o->addTo( bar );
+
+                 QAction *d = new QAction( tr( "Delete Bookmark" ), Resource::loadPixmap( "trash" ),
+                                QString::null, 0, this, 0 );
+                 connect( d, SIGNAL( activated() ),
+                                                this, SLOT( deleteBookmark() ) );
+                d->addTo( bar );
 }
 
 KVNC::~KVNC()
 {
+
+}
+
+void KVNC::newConnection()
+{
+    curServer=new KRFBServer;
+
+                KVNCConnDlg dlg( curServer,this);
+                dlg.showMaximized();
+                        if (dlg.exec()) {
+                                if (!curServer->name.isEmpty())
+                                                bookmarkSelector->addBookmark(curServer);
+                                canvas->openConnection(*curServer);
+                } else
+                                curServer=0;
+}
+
+void KVNC::openConnection( QString name)
+{
+    curServer=bookmarkSelector->getServer(name);
+
+                if (curServer) {
+                                KVNCConnDlg dlg( curServer,this);
+                        dlg.showMaximized();
+
+                        if ( dlg.exec() ) {
+                                        canvas->openConnection(*curServer);
+                                        bookmarkSelector->writeBookmarks();
+                        } else
+                                        curServer=0;
+                }
+}
+
+void KVNC::openConnection( void )
+{
+                openConnection( bookmarkSelector->selectedBookmark());
 }
 
-void KVNC::openURL( const QUrl &url )
+void KVNC::openConnection( QListBoxItem * item)
 {
-    canvas->openURL( url );
+                openConnection(item->text());
 }
 
 void KVNC::setupActions()
 {
     cornerMenu = new QPopupMenu( this );
 
     fullScreenAction = new QAction( tr("Full Screen"), QString::null, 0, 0 );
     connect( fullScreenAction, SIGNAL(activated()),
             this, SLOT( toggleFullScreen() ) );
     fullScreenAction->addTo( cornerMenu );
     fullScreenAction->setEnabled( false );
 
-    optionsAction = new QAction( tr("Settings"), QString::null, 0, 0 );
-    connect( optionsAction, SIGNAL(activated()), this, SLOT( showOptions() ) );
-    optionsAction->addTo( cornerMenu );
-
-    connectAction = new QAction( tr("Connect..."), QString::null, 0, 0 );
-    connect( connectAction, SIGNAL(activated()),
-            canvas, SLOT( openConnection() ) );
-    connectAction->addTo( cornerMenu );
+    ctlAltDelAction = new QAction( tr("Send Contrl-Alt-Delete"), QString::null, 0, 0 );
+    connect( ctlAltDelAction, SIGNAL(activated()),
+            canvas, SLOT( sendCtlAltDel() ) );
+    ctlAltDelAction->addTo( cornerMenu );
+    ctlAltDelAction->setEnabled( false );
 
     disconnectAction = new QAction( tr("Disconnect"), QString::null, 0, 0 );
     connect( disconnectAction, SIGNAL(activated()),
             this, SLOT( closeConnection() ) );
     disconnectAction->addTo( cornerMenu );
     disconnectAction->setEnabled( false );
 }
 
 void KVNC::toggleFullScreen()
 {
-    if ( fullscreen ) {
-        canvas->releaseKeyboard();
-        canvas->reparent( this, 0, QPoint(0,0), false );
-        canvas->setFrameStyle( QFrame::Panel | QFrame::Sunken );
-        setCentralWidget( canvas );
-        canvas->show();
-        fullScreenAction->setText( tr("Full Screen") );
-    } else {
-        canvas->setFrameStyle( QFrame::NoFrame );
-        canvas->reparent( 0,WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop,
-                QPoint(0,0),false);
-        canvas->resize(qApp->desktop()->width(), qApp->desktop()->height());
-        canvas->raise();
-        canvas->setFocus();
-        canvas->grabKeyboard();
-        canvas->show();
-
-        fullScreenAction->setText( tr("Stop Full Screen") );
-    }
-
+                if ( fullscreen ) {
+                        canvas->releaseKeyboard();
+                        canvas->reparent( stack, 0, QPoint(0,0), false );
+                        canvas->setFrameStyle( QFrame::Panel | QFrame::Sunken );
+                        setCentralWidget( stack );
+                        stack->addWidget(canvas,get_unique_id());
+                        stack->raiseWidget(canvas);
+                        canvas->show();
+                        stack->show();
+                        fullScreenAction->setText( tr("Full Screen") );
+                } else {
+                        canvas->setFrameStyle( QFrame::NoFrame );
+                        stack->removeWidget(canvas);
+                                canvas->reparent( 0,WStyle_Tool | WStyle_Customize | WStyle_StaysOnTop,
+                        QPoint(0,0),false);
+                        canvas->resize(qApp->desktop()->width(), qApp->desktop()->height());
+                        canvas->raise();
+                        canvas->setFocus();
+                                canvas->grabKeyboard();
+                                canvas->show();
+                                
+                                fullScreenAction->setText( tr("Stop Full Screen") );
+                }
+                                                
+                                                
     fullscreen = !fullscreen;
 }
 
 void KVNC::closeConnection()
 {
     if ( fullscreen )
         toggleFullScreen();
     canvas->closeConnection();
 }
 
 void KVNC::showMenu()
 {
     QPoint pt = mapToGlobal(cornerButton->pos());
     QSize s = cornerMenu->sizeHint();
     pt.ry() -= s.height();
     pt.rx() -= s.width();
     cornerMenu->popup( pt );
 }
 
 void KVNC::connected()
 {
     static QString msg = tr( "Connected to remote host" );
     statusMessage( msg );
-    connectAction->setEnabled( false );
+    ctlAltDelAction->setEnabled(true);
     disconnectAction->setEnabled( true );
     fullScreenAction->setEnabled( true );
+                stack->raiseWidget(canvas);
 }
 
 void KVNC::loggedIn()
 {
     static QString msg = tr( "Logged in to remote host" );
     statusMessage( msg );
 }
 
 void KVNC::disconnected()
 {
+
+                if ( fullscreen ) 
+                                toggleFullScreen();
     static QString msg = tr( "Connection closed" );
     statusMessage( msg );
-    connectAction->setEnabled( true );
+    ctlAltDelAction->setEnabled(false);
     disconnectAction->setEnabled( false );
     fullScreenAction->setEnabled( false );
+                stack->raiseWidget(bookmarkSelector);
 }
 
 void KVNC::statusMessage( const QString &m )
 {
     Global::statusMessage( m );
 }
 
 void KVNC::error( const QString &msg )
 {
     statusMessage( msg );
     QMessageBox::warning( this, tr("VNC Viewer"), msg );
 }
-
-void KVNC::showOptions()
+void KVNC::deleteBookmark(void)
 {
-    KVNCOptionsDlg *wdg = new KVNCOptionsDlg( canvas->connection()->options(), this );
-    wdg->showMaximized();
-    wdg->exec();
-    delete wdg;
+                bookmarkSelector->deleteBookmark(bookmarkSelector->selectedBookmark());
 }
-
diff --git a/noncore/comm/keypebble/kvnc.h b/noncore/comm/keypebble/kvnc.h
index 92666c5..6e0a385 100644
--- a/noncore/comm/keypebble/kvnc.h
+++ b/noncore/comm/keypebble/kvnc.h
@@ -1,56 +1,66 @@
 // -*- c++ -*-
 
 #ifndef KVNC_H
 #define KVNC_H
 
 #include <qmainwindow.h>
 #include <qurl.h>
+#include <qwidgetstack.h>
+#include "kvncbookmarkdlg.h"
 
 class QAction;
 class KRFBCanvas;
 class QPushButton;
 class QToolBar;
 
 /**
  * Top level window for Keystone.
  *
  * @author Richard Moore, rich@kde.org
  * @version $Id$
  */
 class KVNC : public QMainWindow
 {
   Q_OBJECT
 public: 
   KVNC( const char *name = 0 );
   ~KVNC(); 
 
 public slots:
+  void newConnection();
+  void deleteBookmark();
+  void openConnection(QListBoxItem *);
+  void openConnection(QString);
+  void openConnection(void);
   void toggleFullScreen();
-  void openURL( const QUrl & );
   void closeConnection();
-  void showOptions();
 
 protected:
   void setupActions();
 
 protected slots:
   void showMenu();
 
   void connected();
   void loggedIn();
   void disconnected();
   void statusMessage( const QString & );
   void error( const QString & );
 
 private:
   bool fullscreen;
   KRFBCanvas *canvas;
   QPopupMenu *cornerMenu;
   QPushButton *cornerButton;
   QAction *fullScreenAction;
   QAction *optionsAction;
   QAction *disconnectAction;
+  QAction *ctlAltDelAction;;
   QAction *connectAction;
+
+        KVNCBookmarkDlg * bookmarkSelector;
+        QWidgetStack * stack;
+        KRFBServer * curServer;
 };
 
 #endif // KVNC_H
diff --git a/noncore/comm/keypebble/kvncbookmarkdlg.cpp b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
new file mode 100644
index 0000000..1f97d13
--- a/dev/null
+++ b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
@@ -0,0 +1,220 @@
+#include <qframe.h>
+#include <qvbox.h>
+#include <qcheckbox.h>
+#include <qspinbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwhatsthis.h>
+#include <qfile.h>
+#include <qdir.h>
+#include <qstring.h>
+#include <qapplication.h>
+#include <qlineedit.h>
+#include <qtextstream.h>
+#include <qpushbutton.h>
+#include <qlistbox.h>
+#include <qpe/config.h>
+#include <qpe/global.h>
+#include "krfbserver.h"
+#include "kvncbookmarkdlg.h"
+
+KVNCBookmarkDlg::KVNCBookmarkDlg( QWidget * parent=0, const char * name=0, WFlags f=0 ) 
+
+: KVNCBookmarkDlgBase( parent, name,f)
+{
+                readBookmarks();
+                refresh();
+
+}
+
+KVNCBookmarkDlg::~KVNCBookmarkDlg()
+{
+}
+
+void KVNCBookmarkDlg::addBookmark(KRFBServer * server)
+{
+                if (server) {
+                                servers.append(server);
+                                bookmarkList->insertItem(server->name);
+                                writeBookmarks();
+                                refresh();
+    }
+}
+
+void KVNCBookmarkDlg::deleteBookmark(QString name)
+{
+                KRFBServer * server=0;
+    for ( server=servers.first(); server != 0; server=servers.next() ) {
+        if (server->name==name) {
+                                                servers.remove(servers.at());
+                                                writeBookmarks();
+                                                refresh();
+            return;
+                                }
+    }
+}
+KRFBServer *KVNCBookmarkDlg::getServer(QString name)
+{
+                KRFBServer * server=0;
+    for ( server=servers.first(); server != 0; server=servers.next() ) {
+        if (server->name==name)
+          
+            return server;
+    }
+                return 0;
+}
+
+
+/*
+  Note that the degree of protection offered by the encryption here is
+  only sufficient to avoid the most casual observation of the configuration
+  files. People with access to the files can write down the contents and
+  decrypt it using this source code.
+
+  Conceivably, and at some burden to the user, this encryption could
+  be improved.
+*/
+QString KVNCBookmarkDlg::encipher(const QString& plain)
+{
+    // mainly, we make it long
+    QString cipher;
+    int mix=28730492;
+    for (int i=0; i<(int)plain.length(); i++) {
+        int u = plain[i].unicode();
+        int c = u ^ mix;
+        QString x = QString::number(c,36);
+        cipher.append(QChar('a'+x.length()));
+        cipher.append(x);
+        mix *= u;
+    }
+    return cipher;
+}
+
+QString KVNCBookmarkDlg::decipher(const QString& cipher)
+{
+    QString plain;
+    int mix=28730492;
+    for (int i=0; i<(int)cipher.length();) {
+        int l = cipher[i].unicode()-'a';
+        QString x = cipher.mid(i+1,l); i+=l+1;
+        int u = x.toInt(0,36) ^ mix;
+        plain.append(QChar(u));
+        mix *= u;
+    }
+    return plain;
+}
+
+void KVNCBookmarkDlg::readBookmarks(void)
+{
+                QFile f(QDir::homeDirPath() + QString("/Applications/keypebble/bookmarks"));
+
+                QStringList entry;
+                QString key, val;
+                KRFBServer * server=0;
+                
+                if ( f.open(IO_ReadOnly) ) {
+                                QTextStream t( &f );
+                                QString s;
+                                int n = 1;
+                                while ( !t.eof() ) {
+                                                s = t.readLine();
+                                                
+
+                                                entry=QStringList::split('=',s);
+                                                key=entry[0].stripWhiteSpace().lower();
+                                                val=entry[1].stripWhiteSpace();
+
+                                                if (key=="server") {
+
+                                                                if (server){
+                                                                                servers.append(server);
+                                                                                server=0;
+                                                                }
+                                                                server = new KRFBServer();
+
+                                                                if (!server)
+                                                                                return;
+                                                                server->name=val;
+
+                                                }
+                                                else if (key=="hostname") 
+                                                                server->hostname=val;
+                                                else if (key=="password") 
+                                                        server->password=decipher(val);
+                                                else if (key=="display")  
+                                                                server->display=val.toInt();
+                                                else if (key=="hextile") 
+                                                                server->hexTile=val.toInt();
+                                                else if (key=="corre") 
+                                                                server->corre=val.toInt();
+                                                else if (key=="rre") 
+                                                                server->rre=val.toInt();
+                                                else if (key=="copyrect") 
+                                                                server->copyrect=val.toInt();
+                                                else if (key=="colors256") 
+                                                                server->colors256=val.toInt();
+                                                else if (key=="shared") 
+                                                                server->shared=val.toInt();
+                                                else if (key=="readonly") 
+                                                                server->readOnly=val.toInt();
+                                                else if (key=="deiconify") 
+                                                                server->deIconify=val.toInt();
+                                                else if (key=="updaterate") 
+                                                                server->updateRate=val.toInt();
+
+                                }
+                                if (server){
+                                        servers.append(server);
+                                        server=0;
+                                }
+                                f.close();
+                }
+}
+
+void KVNCBookmarkDlg::writeBookmarks(void)
+{
+                QString filename=Global::applicationFileName("keypebble","bookmarks");
+                                                
+                QFile f(filename);
+
+                QString key, val;
+                KRFBServer * server=0;
+                
+                if ( f.open(IO_ReadWrite) ) {
+                                QTextStream t( &f );
+                                QString s;
+                                int n = 1;
+        KRFBServer *server;
+
+         for ( server=servers.first(); server != 0; server=servers.next() ) {
+                qDebug(server->name);
+          t << "server=" << server->name << '\n';
+                                        t << "\thostname=" << server->hostname << '\n';
+                                        t << "\tpassword=" << encipher(server->password )<< '\n';
+                                        t << "\tdisplay=" << server->display << '\n';
+                                        t << "\thextile=" << server->hexTile << '\n';
+                                        t << "\tcorre=" << server->corre << '\n';
+                                        t << "\trre=" << server->rre << '\n';
+                                        t << "\tcopyrect=" << server->copyrect << '\n';
+                                        t << "\tshared=" << server->shared << '\n';
+                                        t << "\treadonly=" << server->readOnly << '\n';
+                                        t << "\tdeiconify=" << server->deIconify << '\n';
+                                        t << "\tupdaterate=" << server->updateRate << '\n';
+
+                                }
+                                f.close();
+                }
+}
+void KVNCBookmarkDlg::refresh(void)
+{
+                bookmarkList->clear();
+                KRFBServer * server=0;
+    for ( server=servers.first(); server != 0; server=servers.next() ) {
+      bookmarkList->insertItem(server->name);
+    }
+}
+
+QString KVNCBookmarkDlg::selectedBookmark()
+{
+                return bookmarkList->currentText();
+}
diff --git a/noncore/comm/keypebble/kvncconndlg.cpp b/noncore/comm/keypebble/kvncconndlg.cpp
new file mode 100644
index 0000000..6873feb
--- a/dev/null
+++ b/noncore/comm/keypebble/kvncconndlg.cpp
@@ -0,0 +1,75 @@
+#include <qframe.h>
+#include <qvbox.h>
+#include <qcheckbox.h>
+#include <qspinbox.h>
+#include <qlabel.h>
+#include <qlayout.h>
+#include <qwhatsthis.h>
+#include <qapplication.h>
+#include <qlineedit.h>
+#include <qpushbutton.h>
+#include "krfbserver.h"
+
+#include "kvncconndlg.h"
+
+KVNCConnDlg::KVNCConnDlg( KRFBServer *options,
+                                QWidget *parent, char *name, bool modal )
+: KVNCConnDlgBase( parent, name, modal )
+{
+    this->options=options;
+    tmpOptions=*options;
+
+    serverHostname->setText(options->hostname);
+    serverDisplay->setValue(options->display);
+    serverPassword->setText(options->password);
+    serverBookmark->setText(options->name);
+
+                hex->setChecked( options->hexTile );
+                corre->setChecked( options->corre );
+                rre->setChecked( options->rre );
+                copyRect->setChecked( options->copyrect );
+
+                // TODO
+                hex->setEnabled( false );
+                corre->setEnabled( false );
+                rre->setEnabled( false );
+                // /TODO
+
+                deIconify->setChecked( options->deIconify );
+                bit->setChecked( options->colors256 );
+                shared->setChecked( options->shared );
+                timeBox->setValue( options->updateRate );
+                    
+
+}
+
+KVNCConnDlg::~KVNCConnDlg()
+{
+}
+
+void KVNCConnDlg::accept()
+{
+                save();
+                QDialog::accept();
+}
+
+void KVNCConnDlg::save()
+{
+                tmpOptions.hexTile = hex->isChecked();
+                tmpOptions.corre = corre->isChecked();
+                tmpOptions.rre = rre->isChecked();
+                tmpOptions.copyrect = copyRect->isChecked();
+                tmpOptions.deIconify = deIconify->isChecked();
+                tmpOptions.colors256 = bit->isChecked();
+                tmpOptions.shared = shared->isChecked();
+                tmpOptions.hostname = serverHostname->text();
+                tmpOptions.password = serverPassword->text();
+                tmpOptions.display = serverDisplay->value();
+                tmpOptions.name = serverBookmark->text();
+
+                if (!serverBookmark->text().isEmpty()) {
+       if ( options) {
+          *options=tmpOptions;
+        }
+    }
+}
diff --git a/noncore/comm/keypebble/kvncconnectdlg.cpp b/noncore/comm/keypebble/kvncconnectdlg.cpp
deleted file mode 100644
index 467cebf..0000000
--- a/noncore/comm/keypebble/kvncconnectdlg.cpp
+++ b/dev/null
@@ -1,79 +0,0 @@
-#include <qstring.h>
-#include <qlayout.h>
-#include <qframe.h>
-#include <qspinbox.h>
-#include <qcombobox.h>
-#include <qlabel.h>
-#include <qfont.h>
-
-#include <assert.h>
-
-#include "krfbconnection.h"
-#include "kvncoptionsdlg.h"
-#include "kvncconnectdlg.h"
-
-
-KVNCConnectDlg::KVNCConnectDlg( KRFBConnection *con,
-                                QWidget *parent, const char *name )
-  : QDialog( parent, name, true )
-{
-  setCaption( tr("Connect to VNC server") );
-  assert( con );
-  this->con = con;
-
-  QGridLayout *inner = new QGridLayout( this, 3, 2, 6 );
-
-  QLabel *label = new QLabel( tr("Host Name:"), 
-                              this , "hostLabel");
-  hostNameCombo = new QComboBox( true, this );
-  hostNameCombo->setInsertionPolicy( QComboBox::AtTop );
-  hostNameCombo->setMaxCount( 10 );
-  hostNameCombo->insertItem( "localhost" );
-  hostNameCombo->setFocus();
-
-  inner->addWidget( label, 0, 0 );
-  inner->addWidget( hostNameCombo, 0, 1 );
-
-  label = new QLabel( tr("Display Number:"), this, "displayNumber" );
-  displayNumberEdit = new QSpinBox( this );
-
-  inner->addWidget( label, 1, 0 );
-  inner->addWidget( displayNumberEdit, 1, 1 );
-
-  //  if ( viewer->display() != -1 ) {
-  //    displayNumberEdit->setValue( viewer->display() );
-    displayNumberEdit->setValue( 1 );
-    //  }
-
-  label = new QLabel( tr("Password:"), this );
-  inner->addWidget( label, 2, 0 );
-
-  passwordEdit = new QLineEdit( this );
-  passwordEdit->setEchoMode( QLineEdit::Password );
-  inner->addWidget( passwordEdit, 2, 1 );
-
-  inner->setColStretch( 0, 0 );
-  inner->setColStretch( 1, 15 );
-}
-
-
-void KVNCConnectDlg::accept()
-{
-  int dis;
-  //  viewer->setHost(hostNameCombo->currentText());
-  QString temp = displayNumberEdit->text();
-  if(temp.isEmpty())
-    dis = -1;
-  else
-    dis = temp.toUInt();    
-  //  viewer->setDisplay(dis);
-  QDialog::accept();
-}
-
-void KVNCConnectDlg::options()
-{
-  KVNCOptionsDlg *wdg = new KVNCOptionsDlg( con->options(), this );
-  wdg->exec();
-  delete wdg;
-}
-
diff --git a/noncore/comm/keypebble/kvncconnectdlg.h b/noncore/comm/keypebble/kvncconnectdlg.h
deleted file mode 100644
index cf34aab..0000000
--- a/noncore/comm/keypebble/kvncconnectdlg.h
+++ b/dev/null
@@ -1,39 +0,0 @@
-// -*- c++ -*-
-
-#ifndef KVNCCONNECTDLG_H
-#define KVNCCONNECTDLG_H
-
-#include <qdialog.h>
-#include <qspinbox.h>
-#include <qcombobox.h>
-#include <qlineedit.h>
-#include <qurl.h>
-
-class KRFBConnection;
-
-class KVNCConnectDlg : public QDialog
-{
-  Q_OBJECT
-
-public: 
-  KVNCConnectDlg( KRFBConnection *con,
-                  QWidget *parent = 0, const char *name = 0 );
-
-  QString hostname() { return hostNameCombo->currentText(); };
-  int display() { return displayNumberEdit->value(); };
-  QString password() const { return passwordEdit->text(); }
- 
-protected:
-  void accept();
-
-protected slots:
-  void options();
-
-private:
-  QComboBox *hostNameCombo;
-  QSpinBox *displayNumberEdit;
-  QLineEdit *passwordEdit;
-  KRFBConnection *con;
-};
-
-#endif // KVNCCONNECTDLG_H
diff --git a/noncore/comm/keypebble/kvncoptionsdlg.cpp b/noncore/comm/keypebble/kvncoptionsdlg.cpp
deleted file mode 100644
index 9d61c7b..0000000
--- a/noncore/comm/keypebble/kvncoptionsdlg.cpp
+++ b/dev/null
@@ -1,54 +0,0 @@
-#include <qframe.h>
-#include <qvbox.h>
-#include <qcheckbox.h>
-#include <qspinbox.h>
-#include <qlabel.h>
-#include <qlayout.h>
-#include <qwhatsthis.h>
-#include <qapplication.h>
-#include "krfboptions.h"
-
-#include "kvncoptionsdlg.h"
-
-KVNCOptionsDlg::KVNCOptionsDlg( KRFBOptions *options,
-                                QWidget *parent, char *name, bool modal )
-  : VncOptionsBase( parent, name, modal )
-{
-  this->options = options;
-
-  hex->setChecked( options->hexTile );
-  corre->setChecked( options->corre );
-  rre->setChecked( options->rre );
-  copyRect->setChecked( options->copyrect );
-
-  // TODO
-  hex->setEnabled( false );
-  corre->setEnabled( false );
-  rre->setEnabled( false );
-  // /TODO
-
-  deIconify->setChecked( options->deIconify );
-  bit->setChecked( options->colors256 );
-  shared->setChecked( options->shared );
-  timeBox->setValue( options->updateRate );
-}
-
-KVNCOptionsDlg::~KVNCOptionsDlg()
-{
-}
-
-void KVNCOptionsDlg::accept()
-{
-  options->hexTile = hex->isChecked();
-  options->corre = corre->isChecked();
-  options->rre = rre->isChecked();
-  options->copyrect = copyRect->isChecked();
-  options->deIconify = deIconify->isChecked();
-  options->colors256 = bit->isChecked();
-  options->shared = shared->isChecked();
-  options->updateRate = timeBox->value();
-  options->writeSettings();
-
-  QDialog::accept();
-}
-
diff --git a/noncore/comm/keypebble/kvncoptionsdlg.h b/noncore/comm/keypebble/kvncoptionsdlg.h
deleted file mode 100644
index a166490..0000000
--- a/noncore/comm/keypebble/kvncoptionsdlg.h
+++ b/dev/null
@@ -1,30 +0,0 @@
-// -*- c++ -*-
-
-#ifndef KVNCOPTIONSDIALOG_H
-#define KVNCOPTIONSDIALOG_H
-
-#include "vncoptionsbase.h"
-
-class KRFBOptions;
-
-class KVNCOptionsDlg : public VncOptionsBase
-{
-Q_OBJECT
-
-public:
-  KVNCOptionsDlg( KRFBOptions *options,
-                  QWidget *parent = 0, char *name = 0, bool modal = true );
-  ~KVNCOptionsDlg();
-
-protected:
-  void accept();
-
-private:
-  KRFBOptions *options;
-};
-
-#endif // KVNCOPTIONSDIALOG_H
-
-
-
-
diff --git a/noncore/comm/keypebble/main.cpp b/noncore/comm/keypebble/main.cpp
index ee3cd79..bc7782c 100644
--- a/noncore/comm/keypebble/main.cpp
+++ b/noncore/comm/keypebble/main.cpp
@@ -1,17 +1,15 @@
 
 
 #include <qurl.h>
 #include <qpe/qpeapplication.h>
 #include "kvnc.h"
 
 int main( int argc, char **argv )
 {
   QPEApplication app( argc, argv );
   KVNC *view = new KVNC( "Keypebble" );
   app.showMainWidget( view );
 
-  if ( argc > 1 )
-    view->openURL( QUrl(argv[1]) );
-
   return app.exec();
 }
+