8 files changed, 112 insertions, 78 deletions

diff --git a/noncore/comm/keypebble/config.in b/noncore/comm/keypebble/config.in
index 20384aa..8a800b9 100644
--- a/noncore/comm/keypebble/config.in
+++ b/noncore/comm/keypebble/config.in
@@ -1,4 +1,4 @@
   config KEYPEBBLE
     boolean "opie-keypebble (Virtual Network Computing VNC viewer)"
     default "y"
-    depends ( LIBQPE || LIBQPE-X11 )
+    depends ( LIBQPE || LIBQPE-X11 ) && LIBOPIE2CORE
diff --git a/noncore/comm/keypebble/keypebble.pro b/noncore/comm/keypebble/keypebble.pro
index 3515016..7631e4e 100644
--- a/noncore/comm/keypebble/keypebble.pro
+++ b/noncore/comm/keypebble/keypebble.pro
@@ -1,35 +1,34 @@
-CONFIG          += qt warn_on  quick-app
+CONFIG          += qt warn_on 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
+        INTERFACES= kvncconndlgbase.ui kvncbookmarkdlgbase.ui
 
-INCLUDEPATH += $(OPIEDIR)/include
+INCLUDEPATH     += $(OPIEDIR)/include
 DEPENDPATH      += $(OPIEDIR)/include
-LIBS            += -lqpe
+LIBS            += -lqpe -lopiecore2
 
         TARGET  = keypebble
 
 include ( $(OPIEDIR)/include.pro )
diff --git a/noncore/comm/keypebble/krfbbuffer.cpp b/noncore/comm/keypebble/krfbbuffer.cpp
index 4cec0c2..4b29612 100644
--- a/noncore/comm/keypebble/krfbbuffer.cpp
+++ b/noncore/comm/keypebble/krfbbuffer.cpp
@@ -1,25 +1,33 @@
-#include <assert.h>
-#include <qimage.h>
-#include <qpainter.h>
-#include <qapplication.h>
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 #include "krfbconnection.h"
 #include "krfbserverinfo.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+
+/* QT */
+#include <qimage.h>
+#include <qpainter.h>
+#include <qapplication.h>
+
+/* STD */
+#include <assert.h>
+
 //
 // Endian stuff
 //
-#ifndef KDE_USE_FINAL
+#ifndef OPIE_NO_DEBUG
 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))
 
@@ -30,60 +38,60 @@ KRFBBuffer::KRFBBuffer( KRFBDecoder *decoder,
   assert( decoder );
   this->decoder = decoder;
   pix = new QPixmap();
 }
 
 KRFBBuffer::~KRFBBuffer()
 {
   delete pix;
 }
 
 void KRFBBuffer::resize( int w, int h )
 {
-  qWarning( "Resizing buffer" );
+  owarn << "Resizing buffer" << oendl; 
 
   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" );
+    owarn << "Buffer got a key" << oendl; 
 
   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" );
+//  owarn << "Got copy rect" << oendl; 
   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 scaleFactor=decoder->con->options()->scaleFactor;
   int redMax = Swap16IfLE( decoder->format->redMax );
diff --git a/noncore/comm/keypebble/krfbcanvas.cpp b/noncore/comm/keypebble/krfbcanvas.cpp
index cd1fda0..b3525df 100644
--- a/noncore/comm/keypebble/krfbcanvas.cpp
+++ b/noncore/comm/keypebble/krfbcanvas.cpp
@@ -1,18 +1,22 @@
 #include "krfbconnection.h"
 #include "krfbcanvas.h"
 #include "krfbbuffer.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
+using namespace Opie::Core;
 
+/* QT */
 #include <qclipboard.h>
 
 KRFBCanvas::KRFBCanvas( QWidget *parent, const char *name )
   : QScrollView( parent, name )
 {
     connection_ = new KRFBConnection();
     connect( connection_, SIGNAL( loggedIn() ),
             this, SLOT( loggedIn() ) );
 
     loggedIn_ = false;
 
                 //QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold);
@@ -33,25 +37,25 @@ void KRFBCanvas::openConnection(KRFBServer server)
 {
 
   
                 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" );
+      owarn << "openURL invoked when logged in\n" << oendl; 
       return;
   }
 
   QCString host = url.host().latin1();
   int display = url.port();
 
 //  connection_->connectTo( host, display );
 }
 
 void KRFBCanvas::closeConnection()
 {
   loggedIn_ = false;
@@ -65,25 +69,25 @@ void KRFBCanvas::closeConnection()
 
 
 void KRFBCanvas::bell()
 {
   if ( connection_->options()->deIconify ) {
     topLevelWidget()->raise();
     topLevelWidget()->show();
   }
 }
 
 void KRFBCanvas::loggedIn()
 {
-  qWarning( "Ok, we're logged in" );
+  owarn << "Ok, we're logged in" << oendl; 
 
   //
   // 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) ) );
diff --git a/noncore/comm/keypebble/krfbconnection.cpp b/noncore/comm/keypebble/krfbconnection.cpp
index b447046..33e0563 100644
--- a/noncore/comm/keypebble/krfbconnection.cpp
+++ b/noncore/comm/keypebble/krfbconnection.cpp
@@ -1,22 +1,29 @@
-#include <assert.h>
-#include <qsocket.h>
-#include <qtimer.h>
-#include <string.h>
-
 #include "krfbconnection.h"
 #include "krfblogin.h"
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+
+/* QT */
+#include <qsocket.h>
+#include <qtimer.h>
+
+/* STD */
+#include <assert.h>
+#include <string.h>
+
 KRFBConnection::KRFBConnection( QObject *parent )
                 : QObject( parent, "KRFBConnection" )
 {
                 portBase_ = 5900;
                 currentState_ = Disconnected;
                 sock = 0;
                 minData_ = 0;
                 options_ = new KRFBServer();
                 updater = 0;
                 decoder_ = 0;
                 buffer_ = 0;
 }
@@ -34,33 +41,33 @@ void KRFBConnection::connectTo( KRFBServer server)
                 if ( currentState_ != Disconnected )
                                 disconnect();
                 
     (*options_)=server;
 
                 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() ) );
 
-                qWarning( "Connecting..." );
+                owarn << "Connecting..." << oendl; 
 
                 currentState_ = Connecting;
                 sock->connectToHost( options_->hostname.latin1(), portBase_ + options_->display );
 }
 
 void KRFBConnection::disconnect()
 {
-                qWarning( "Disconnecting from server" );
+                owarn << "Disconnecting from server" << oendl; 
 
                 if ( ( currentState_ != Disconnected )
                                                 && ( currentState_ != Disconnecting )
                                                 && sock ) {
                                 currentState_ = Disconnecting;
 
                                 connect( sock, SIGNAL( delayedCloseFinished() ), SLOT( disconnectDone() ) );
                                 sock->close();
 
                                 if ( sock->state() != QSocket::Closing )
                                                 disconnectDone();
                 }
@@ -73,36 +80,36 @@ void KRFBConnection::disconnectDone()
                 sock = 0;
                 minData_ = 0;
                 delete updater;
                 delete decoder_;
                 delete buffer_;
                 emit disconnected();
 }
 
 void KRFBConnection::gotSocketConnection()
 {
                 currentState_ = LoggingIn;
 
-                qWarning( "Connected, logging in..." );
+                owarn << "Connected, logging in..." << oendl; 
 
                 static QString statusMsg = tr( "Connected" );
                 emit statusChanged( statusMsg );
 
                 // Do some login stuff
                 login = new KRFBLogin( this );
 }
 
 void KRFBConnection::gotRFBConnection()
 {
-                qWarning( "Logged into server" );
+                owarn << "Logged into server" << oendl; 
 
                 currentState_ = Connected;
                 emit connected();
 
                 // 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_ );
 
@@ -113,25 +120,25 @@ void KRFBConnection::gotRFBConnection()
                 decoder_->start();
 
                 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 );
+                owarn << "KRFBConnection: Socket error " << err << "" << oendl; 
 
                 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;
@@ -163,29 +170,29 @@ void KRFBConnection::gotMoreData()
                                 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" );
+                                //    owarn << "No need to wait for data" << oendl; 
                                 emit gotEnoughData();
                 }
                 else {
-                                //    qWarning( "Waiting for %u bytes", sz );
+                                //    owarn << "Waiting for " << sz << " bytes" << oendl; 
                                 minData_ = sz;
                                 connect( sock, SIGNAL( readyRead() ), SLOT( gotMoreData() ) );
                 }
 }
 
 int KRFBConnection::read( void *buf, int sz )
 {
                 return sock->readBlock( (char *)  buf, sz );
 }
 
 int KRFBConnection::write( void *buf, int sz )
 {
diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp
index db95154..69457e2 100644
--- a/noncore/comm/keypebble/krfbdecoder.cpp
+++ b/noncore/comm/keypebble/krfbdecoder.cpp
@@ -1,26 +1,31 @@
 #include "krfbconnection.h"
 #include "krfbserverinfo.h"
 #include "krfbdecoder.h"
 #include "krfbbuffer.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
 
+/* QT */
 #include <qpixmap.h>
 
+/* STD */
 #include <assert.h>
 
 //
 // Endian stuff
 //
-#ifndef KDE_USE_FINAL
+#ifndef OPIE_NO_DEBUG
 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))
 
@@ -126,37 +131,37 @@ KRFBDecoder::~KRFBDecoder()
 }
 
 void KRFBDecoder::start()
 {
   sendClientInit();
 }
 
 void KRFBDecoder::sendClientInit()
 {
   con->write( &( con->options()->shared ), 1 );
 
   // Wait for server init
-  qWarning( "Waiting for server init" );
+  owarn << "Waiting for server init" << oendl; 
 
   static QString statusMsg = tr( "Waiting for server initialization..." );
   emit status( statusMsg );
 
   currentState = AwaitingServerInit;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerInit() ) );
   con->waitForData( ServerInitLength );
 }
 
 void KRFBDecoder::gotServerInit()
 {
-  qWarning( "Got server init" );
+  owarn << "Got server init" << oendl; 
   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 );
 
@@ -172,63 +177,63 @@ void KRFBDecoder::gotServerInit()
   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 );
+  owarn << "Width = " << info->width << ", Height = " << info->height << "" << oendl; 
   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" );
+  owarn << "Waiting for desktop name" << oendl; 
 
   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" );
+  owarn << "Got desktop name" << oendl; 
 
   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() );
+  owarn << "Desktop: " << info->name.latin1() << "" << oendl; 
 
   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 );
@@ -362,25 +367,25 @@ void KRFBDecoder::sendUpdateRequest( bool incremental )
   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" );
+  //  owarn << "Got update header" << oendl; 
 
   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();
@@ -397,37 +402,37 @@ void KRFBDecoder::gotUpdateHeader()
       currentState = Error;
       emit error( protocolError );
     }
     return;
   }
 
   CARD8 padding;
   con->read( &padding, 1 );
 
   con->read( &noRects, 2 );
   noRects = Swap16IfLE( noRects );
 
-  //  qWarning( "Expecting %d rects", noRects );
+  //  owarn << "Expecting " << noRects << " rects" << oendl; 
 
   // 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" );
+  //  owarn << "Got rect header" << oendl; 
 
   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 );
@@ -437,125 +442,125 @@ void KRFBDecoder::gotRectHeader()
 
   //  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" );
+      //    owarn << "Raw encoding" << oendl; 
     handleRawRect();
   }
   else if ( encoding == CopyRectEncoding ) {
-//    qWarning( "CopyRect encoding" );
+//    owarn << "CopyRect encoding" << oendl; 
     handleCopyRect();
   }
   else if ( encoding == RreEncoding ) {
-    qWarning( "RRE encoding" );
+    owarn << "RRE encoding" << oendl; 
     handleRRERect();
   }
   else if ( encoding == CorreEncoding ) {
-    qWarning( "CoRRE encoding" );
+    owarn << "CoRRE encoding" << oendl; 
     handleCoRRERect();
   }
   else if ( encoding == HexTileEncoding ) {
-    qWarning( "HexTile encoding" );
+    owarn << "HexTile encoding" << oendl; 
     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 );
+    owarn << "Unknown encoding, " << msg << "" << oendl; 
     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" );
+    //  owarn << "Handling a raw rect chunk" << oendl; 
 
     //  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 );
+  //  owarn << "Waiting for raw rect chunk, " << count << "" << oendl; 
 
   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" );
+  //  owarn << "Got raw rect chunk" << oendl; 
 
   //
   // 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 );
+    //    owarn << "There are " << noRects << " rects left" << oendl; 
 
     if ( noRects ) {
       currentState = AwaitingRectHeader;
       connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
       con->waitForData( RectHeaderLength );
     }
     else {
       // we are now ready for the next update - no need to wait for the timer
       currentState = Idle;
       sendUpdateRequest (1);
     }
   }
@@ -581,48 +586,48 @@ void KRFBDecoder::gotCopyRectPos()
   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 );
+  //    owarn << "There are " << noRects << " rects left" << oendl; 
 
   if ( noRects ) {
     currentState = AwaitingRectHeader;
     connect( con, SIGNAL( gotEnoughData() ), SLOT( gotRectHeader() ) );
     con->waitForData( RectHeaderLength );
   }
   else
     currentState = Idle;
 }
 
 void KRFBDecoder::handleRRERect()
 {
-  qWarning( "RRE not implemented" );
+  owarn << "RRE not implemented" << oendl; 
 }
 
 void KRFBDecoder::handleCoRRERect()
 {
-  qWarning( "CoRRE not implemented" );
+  owarn << "CoRRE not implemented" << oendl; 
 }
 
 void KRFBDecoder::handleHexTileRect()
 {
-  qWarning( "HexTile not implemented" );
+  owarn << "HexTile not implemented" << oendl; 
 }
 
 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;
@@ -664,25 +669,25 @@ void KRFBDecoder::sendCutEvent( const QString &unicode )
   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" );
+  owarn << "Got server cut" << oendl; 
 
   currentState = AwaitingServerCutLength;
   connect( con, SIGNAL( gotEnoughData() ), SLOT( gotServerCutLength() ) );
   con->waitForData( ServerCutLenLength );
 }
 
 void KRFBDecoder::gotServerCutLength()
 {
   assert( currentState = AwaitingServerCutLength );
   disconnect( con, SIGNAL( gotEnoughData() ),
               this, SLOT( gotServerCutLength() ) );
 
@@ -712,62 +717,62 @@ void KRFBDecoder::gotServerCutText()
   // 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 );
+  owarn << "Server cut: " << cutbuf << "" << oendl; 
 
   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" );
+    owarn << "Async handled in weird state" << oendl; 
     currentState = oldState;
   };
 }
 
 void KRFBDecoder::gotBell()
 {
-  qWarning( "Got server bell" );
+  owarn << "Got server bell" << oendl; 
   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" );
+    owarn << "Async handled in weird state" << oendl; 
     currentState = oldState;
   };
 }
 
 void KRFBDecoder::sendKeyPressEvent( QKeyEvent *event )
 {
   int key;
   key = toKeySym( event );
   if ( key ) {
     key = Swap32IfLE( key );
 
     CARD8 mask = true;
diff --git a/noncore/comm/keypebble/krfblogin.cpp b/noncore/comm/keypebble/krfblogin.cpp
index 2bbd110..92005d2 100644
--- a/noncore/comm/keypebble/krfblogin.cpp
+++ b/noncore/comm/keypebble/krfblogin.cpp
@@ -1,23 +1,28 @@
-#include <assert.h>
+#include "krfblogin.h"
+#include "krfbconnection.h"
 
+/* OPIE */
+#include <opie2/odebug.h>
+using namespace Opie::Core;
+
+/* QT */
+#include <qtimer.h>
 
+/* STD */
+#include <assert.h>
 extern "C" {
 #include "vncauth.h"
 }
 
-#include "krfblogin.h"
-#include "krfbconnection.h"
-#include <qtimer.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,
@@ -43,154 +48,154 @@ const int endianTest = 1;
 
 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&) ) );
 
 
-  qWarning( "Waiting for server version..." );
+  owarn << "Waiting for server version..." << oendl; 
 
   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" );
+  owarn << "Got server version" << oendl; 
 
   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 );
+    owarn << msg << oendl; 
     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 );
+  owarn << "Server Version: " << serverMajor << "." << serverMinor << "" << oendl; 
 
   if ( serverMajor != 3 ) {
     QString msg = tr( "Error: Unsupported server version, %1" )
       .arg( rfbString );
 
-    qWarning( msg );
+    owarn << msg << oendl; 
     emit error( msg );
     currentState = Error;
     return;    
   }
   
   if ( serverMinor != 3 ) {
-    qWarning( "Minor version mismatch: %d", serverMinor );
+    owarn << "Minor version mismatch: " << serverMinor << "" << oendl; 
   }
 
   // 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" );
+    owarn << "Failed" << oendl; 
     // 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 );
+    owarn << "Unknown authentication scheme, 0x" << scheme << "" << oendl; 
     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->options_->password.isNull() ) {
-    qWarning( "krfblogin needs a password" );
+    owarn << "krfblogin needs a password" << oendl; 
     emit passwordRequired( con );
   }
 
   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, QCString(con->options_->password.latin1()).data() );
@@ -207,47 +212,47 @@ void KRFBLogin::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 );
+  owarn << "Authentication Result is 0x" << result << "" << oendl; 
 
   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" );
+    owarn << "Dammit" << oendl; 
     emit status( statusMsgFailed );
     emit error( failed );
     break;
   case AuthTooMany:
     emit status( statusMsgTooMany );
     emit error( tooMany );    
     break;
   default:
-    qWarning( "Invalid authentication result, %lx", result );
+    owarn << "Invalid authentication result, " << result << "" << oendl; 
     break;
   }
 }
 
 void KRFBLogin::sendClientVersion()
 {
-  qWarning( "Sending client version" );
+  owarn << "Sending client version" << oendl; 
   con->write( (void*)"RFB 003.003\n", ClientVersionLength );
 }
diff --git a/noncore/comm/keypebble/kvncbookmarkdlg.cpp b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
index ef2fa12..149c398 100644
--- a/noncore/comm/keypebble/kvncbookmarkdlg.cpp
+++ b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
@@ -1,17 +1,23 @@
+#include "kvncbookmarkdlg.h"
+
+/* OPIE */
+#include <opie2/odebug.h>
+#include <qpe/global.h>
+using namespace Opie::Core;
+
+/* QT */
 #include <qdir.h>
 #include <qtextstream.h>
 #include <qlistbox.h>
-#include <qpe/global.h>
-#include "kvncbookmarkdlg.h"
 
 KVNCBookmarkDlg::KVNCBookmarkDlg( QWidget * parent, const char * name, WFlags f ) 
 
 : KVNCBookmarkDlgBase( parent, name,f)
 {
                 readBookmarks();
                 refresh();
 
 }
 
 KVNCBookmarkDlg::~KVNCBookmarkDlg()
 {
@@ -166,25 +172,25 @@ void KVNCBookmarkDlg::writeBookmarks(void)
                 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);
+                odebug << server->name << oendl; 
           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';