merge noncore/comm/*

5 files changed, 25 insertions, 26 deletions

diff --git a/noncore/comm/keypebble/keypebble.pro b/noncore/comm/keypebble/keypebble.pro
index 7af60f9..b3cb172 100644
--- a/noncore/comm/keypebble/keypebble.pro
+++ b/noncore/comm/keypebble/keypebble.pro
@@ -1,55 +1,55 @@
-TEMPLATE        = app
-CONFIG          += qt warn_on release
-DESTDIR         = $(OPIEDIR)/bin
+CONFIG          += qt warn_on release quick-app
 HEADERS		= d3des.h \
 		  krfbbuffer.h \
 		  krfbcanvas.h \
 		  krfbconnection.h \
 		  krfbdecoder.h \
 		  krfblogin.h \
 		  krfbserver.h \
 		  krfbserverinfo.h \
 		  kvnc.h \
 		  kvncconndlg.h \
 		  kvncbookmarkdlg.h \		  
 		  vncauth.h
 SOURCES		= d3des.c \
 		  vncauth.c \
 		  krfbbuffer.cpp \
 		  krfbcanvas.cpp \
 		  krfbconnection.cpp \
 		  krfbdecoder.cpp \
 		  krfblogin.cpp \
 		  krfbserver.cpp \
 		  kvnc.cpp \
 		  kvncconndlg.cpp \
 		  kvncbookmarkdlg.cpp \
 		  main.cpp
 INTERFACES	= kvncconndlgbase.ui \
 						kvncbookmarkdlgbase.ui
-TARGET          = keypebble
+
 INCLUDEPATH += $(OPIEDIR)/include
 DEPENDPATH      += $(OPIEDIR)/include
 LIBS            += -lqpe
 
+TARGET		= keypebble
+
 TRANSLATIONS = ../../../i18n/de/keypebble.ts \
 	 ../../../i18n/nl/keypebble.ts \
 	 ../../../i18n/da/keypebble.ts \
 	 ../../../i18n/xx/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
 
 
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp
index 33418ae..dc90d9c 100644
--- a/noncore/comm/keypebble/krfbdecoder.cpp
+++ b/noncore/comm/keypebble/krfbdecoder.cpp
@@ -145,611 +145,614 @@ void KRFBDecoder::sendClientInit()
 
   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/con->options()->scaleFactor, info->height /con->options()->scaleFactor);
 
   // 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();
+  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 );
 
   if ( msgType != UpdateId ) {
     // We might have a bell or server cut
     if ( msgType == ServerCutId ) {
       oldState = currentState;
       gotServerCut();
     }
     else if ( msgType == BellId ) {
       oldState = currentState;
       gotBell();
     }
     else {
       int msg = msgType;
       QString protocolError = tr( "Protocol Error: Message Id %1 was "
                                     "found when expecting an update "
                                     "message." ).arg( msg );
       currentState = Error;
       emit error( protocolError );
     }
     return;    
   }
 
   CARD8 padding;
   con->read( &padding, 1 );
 
   con->read( &noRects, 2 );
   noRects = Swap16IfLE( noRects );
 
   //  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
+    else {
+      // we are now ready for the next update - no need to wait for the timer
       currentState = Idle;
+      sendUpdateRequest (1);
+    }
   }
 }
 
 //
 // 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;
     }
   }
 
 	// HACK: Scaling
   CARD16 x = Swap16IfLE( e->x() * con->options()->scaleFactor );
   CARD16 y = Swap16IfLE( e->y() *	con->options()->scaleFactor );
 
   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';
 
   /* For some reason QApplication::clipboard()->setText() segfaults when called
    * from within keypebble's mass of signals and slots 
   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 ) {
diff --git a/noncore/comm/keypebble/kvnc.cpp b/noncore/comm/keypebble/kvnc.cpp
index 48a442c..c89dec5 100644
--- a/noncore/comm/keypebble/kvnc.cpp
+++ b/noncore/comm/keypebble/kvnc.cpp
@@ -1,295 +1,295 @@
 #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 "krfbconnection.h"
 #include "kvncconndlg.h"
 #include "krfbserver.h"
 
 static int u_id = 1;
-static int get_unique_id() 
-{   
+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 ,WStyle_ContextHelp)
+KVNC::KVNC(  QWidget *parent, const char *name, WFlags f) : QMainWindow( 0, name ,WStyle_ContextHelp)
 {
     setCaption( tr("VNC Viewer") );
     fullscreen = false;
 
 		stack = new QWidgetStack( this );
 		setCentralWidget( stack );
 
 		bookmarkSelector=new KVNCBookmarkDlg();
 		stack->addWidget(bookmarkSelector,get_unique_id());
-		stack->raiseWidget( bookmarkSelector );                                        
+		stack->raiseWidget( bookmarkSelector );
 
 		canvas = new KRFBCanvas( stack, "canvas" );
 		stack->addWidget(canvas,get_unique_id());
     setCentralWidget( stack );
 
 
     connect( bookmarkSelector->bookmarkList, SIGNAL(clicked(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 );
 
 		stack->raiseWidget( bookmarkSelector );
 
 
 		bar= new QToolBar( this );
 		setToolBarsMovable( false );
 		setRightJustification(false);
 
 
 		 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( "fileopen" ),
 				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::openConnection( QListBoxItem * item)
 {
     if (item)
   		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 );
 
     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 );
 
     doubleClickAction = new QAction( tr("Next Click is Double Click"), QString::null, 0, 0 );
     connect( doubleClickAction, SIGNAL(activated()),
 	    canvas, SLOT( markDoubleClick() ) );
     doubleClickAction->addTo( cornerMenu );
     doubleClickAction->setEnabled( false );
 
     rightClickAction = new QAction( tr("Next Click is Right Click"), QString::null, 0, 0 );
     connect( rightClickAction, SIGNAL(activated()),
 	    canvas, SLOT( markRightClick() ) );
     rightClickAction->addTo( cornerMenu );
     rightClickAction->setEnabled( false );
 }
 
 void KVNC::toggleFullScreen()
 {
 		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 );
     ctlAltDelAction->setEnabled(true);
     disconnectAction->setEnabled( true );
     fullScreenAction->setEnabled( true );
     doubleClickAction->setEnabled( false );
     rightClickAction->setEnabled( true );
 		stack->raiseWidget(canvas);
 	 	bar->hide();
 }
 
 void KVNC::loggedIn()
 {
     static QString msg = tr( "Logged in to remote host" );
     statusMessage( msg );
 }
 
 void KVNC::disconnected()
 {
 
-		if ( fullscreen ) 
+		if ( fullscreen )
 				toggleFullScreen();
     static QString msg = tr( "Connection closed" );
     statusMessage( msg );
     ctlAltDelAction->setEnabled(false);
     disconnectAction->setEnabled( false );
     fullScreenAction->setEnabled( false );
     doubleClickAction->setEnabled( false );
     rightClickAction->setEnabled( false );
 		stack->raiseWidget(bookmarkSelector);
 	 	bar->show();
 }
 
 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::deleteBookmark(void)
 {
 		bookmarkSelector->deleteBookmark(bookmarkSelector->selectedBookmark());
 }
diff --git a/noncore/comm/keypebble/kvnc.h b/noncore/comm/keypebble/kvnc.h
index 51c7151..7b7cc91 100644
--- a/noncore/comm/keypebble/kvnc.h
+++ b/noncore/comm/keypebble/kvnc.h
@@ -1,69 +1,70 @@
 // -*- c++ -*-
 
 #ifndef KVNC_H
 #define KVNC_H
 
 #include <qmainwindow.h>
 #include <qtoolbar.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:
+  KVNC( QWidget *parent = 0, const char *name = 0, WFlags f = 0 );
+  ~KVNC();
 
 public slots:
   void newConnection();
   void deleteBookmark();
   void openConnection(QListBoxItem *);
   void openConnection(QString);
   void openConnection(void);
   void toggleFullScreen();
   void closeConnection();
+  static QString appName() { return QString::fromLatin1("keypebble"); }
 
 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;
   QAction *rightClickAction;
   QAction *doubleClickAction;
 	QToolBar * bar;
 
 	KVNCBookmarkDlg * bookmarkSelector;
 	QWidgetStack * stack;
 	KRFBServer * curServer;
 };
 
 #endif // KVNC_H
diff --git a/noncore/comm/keypebble/main.cpp b/noncore/comm/keypebble/main.cpp
index bc7782c..11f67fc 100644
--- a/noncore/comm/keypebble/main.cpp
+++ b/noncore/comm/keypebble/main.cpp
@@ -1,15 +1,10 @@
 
 
-#include <qurl.h>
+
 #include <qpe/qpeapplication.h>
 #include "kvnc.h"
+#include <opie/oapplicationfactory.h>
 
-int main( int argc, char **argv )
-{
-  QPEApplication app( argc, argv );
-  KVNC *view = new KVNC( "Keypebble" );
-  app.showMainWidget( view );
 
-  return app.exec();
-}
 
+OPIE_EXPORT_APP( OApplicationFactory<KVNC> )