fix includes

24 files changed, 2 insertions, 99 deletions

diff --git a/noncore/apps/tinykate/libkate/document/katedocument.cpp b/noncore/apps/tinykate/libkate/document/katedocument.cpp
index 6807544..f05e21a 100644
--- a/noncore/apps/tinykate/libkate/document/katedocument.cpp
+++ b/noncore/apps/tinykate/libkate/document/katedocument.cpp
@@ -1,452 +1,450 @@
 /***************************************************************************
                           katedocument.cpp  -  description
                              -------------------
     begin                : Mon Jan 15 2001
     copyright            : (C) 2001 by Christoph "Crossfire" Cullmann
                            (C) 2002 by Joseph Wenninger
     email                : crossfire@babylon2k.de
                            jowenn@kde.org
  
 ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
    Copyright (C) 1998, 1999 Jochen Wilhelmy
                             digisnap@cs.tu-berlin.de
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 #include "katedocument.h"
 
 
 #include <qfileinfo.h>
 #include <qdatetime.h>
 
 #include <kmessagebox.h>
-#include <klocale.h>
 #include <qpe/config.h>
 #include <qstring.h>
 
 #include <sys/time.h>
 #include <unistd.h>
 
 #include <stdio.h>
 
 #include <qtimer.h>
 #include <qobject.h>
 #include <qapplication.h>
 #include <qclipboard.h>
 #include <qfont.h>
 #include <qpainter.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qtextcodec.h>
 #include <kglobal.h>
 
-#include <klocale.h>
 //#include <kcharsets.h>
 #include <kdebug.h>
 //#include <kinstance.h>
 
 #include <kglobalsettings.h>
 //#include <kaction.h>
 //#include <kstdaction.h>
 
 #include "../view/kateview.h"
 #include "katebuffer.h"
 #include "katetextline.h"
 
 #include "katecmd.h"
 
 KateAction::KateAction(Action a, PointStruc &cursor, int len, const QString &text)
   : action(a), cursor(cursor), len(len), text(text) {
 }
 
 KateActionGroup::KateActionGroup(PointStruc &aStart, int type)
   : start(aStart), action(0L), undoType(type) {
 }
 
 KateActionGroup::~KateActionGroup() {
   KateAction *current, *next;
 
   current = action;
   while (current) {
     next = current->next;
     delete current;
     current = next;
   }
 }
 
 void KateActionGroup::insertAction(KateAction *a) {
   a->next = action;
   action = a;
 }
 
 const char * KateActionGroup::typeName(int type)
 {
   // return a short text description of the given undo group type suitable for a menu
   // not the lack of i18n's, the caller is expected to handle translation
   switch (type) {
   case ugPaste : return "Paste Text";
   case ugDelBlock : return "Selection Overwrite";
   case ugIndent : return "Indent";
   case ugUnindent : return "Unindent";
   case ugComment : return "Comment";
   case ugUncomment : return "Uncomment";
   case ugReplace : return "Text Replace";
   case ugSpell : return "Spell Check";
   case ugInsChar : return "Typing";
   case ugDelChar : return "Delete Text";
   case ugInsLine : return "New Line";
   case ugDelLine : return "Delete Line";
   }
   return "";
 }
 
 const int KateDocument::maxAttribs = 32;
 
 QStringList KateDocument::searchForList = QStringList();
 QStringList KateDocument::replaceWithList = QStringList();
 
 uint KateDocument::uniqueID = 0;
 
 QPtrDict<KateDocument::KateDocPrivate>* KateDocument::d_ptr = 0;    
 
 
 KateDocument::KateDocument(bool bSingleViewMode, bool bBrowserView,
                                            QWidget *parentWidget, const char *widgetName,
                                            QObject *, const char *)
   : Kate::Document (),
     myFont(KGlobalSettings::generalFont()), myFontBold(KGlobalSettings::generalFont()), myFontItalic(KGlobalSettings::generalFont()), myFontBI(KGlobalSettings::generalFont()),
     myFontMetrics (myFont), myFontMetricsBold (myFontBold), myFontMetricsItalic (myFontItalic), myFontMetricsBI (myFontBI),
     hlManager(HlManager::self ())
 {
  
   d(this)->hlSetByUser = false;  
   PreHighlightedTill=0;
   RequestPreHighlightTill=0;
 
   m_bSingleViewMode=bSingleViewMode;
   m_bBrowserView = bBrowserView;
 
   m_url = QString::null;
 
   // NOTE: QFont::CharSet doesn't provide all the charsets KDE supports
   // (esp. it doesn't distinguish between UTF-8 and iso10646-1) 
 
   myEncoding = QString::fromLatin1(QTextCodec::codecForLocale()->name());
 
   maxLength = -1;
 
   setFont (KGlobalSettings::generalFont());
 
   myDocID = uniqueID;
   uniqueID++;
 
   myDocName = QString ("");
   fileInfo = new QFileInfo ();
 
   myCmd = new KateCmd (this);
 
   connect(this,SIGNAL(modifiedChanged ()),this,SLOT(slotModChanged ()));
 
   buffer = new KWBuffer;
   connect(buffer, SIGNAL(linesChanged(int)), this, SLOT(slotBufferChanged()));
 //  connect(buffer, SIGNAL(textChanged()), this, SIGNAL(textChanged()));
   connect(buffer, SIGNAL(needHighlight(long,long)),this,SLOT(slotBufferHighlight(long,long)));
 
   colors[0] = KGlobalSettings::baseColor();
   colors[1] = KGlobalSettings::highlightColor();
 
   m_attribs = new Attribute[maxAttribs];
 
   m_highlight = 0L;
   tabChars = 8;
 
   m_singleSelection = false;
 
   newDocGeometry = false;
   readOnly = false;
   newDoc = false;
 
   modified = false;
 
   undoList.setAutoDelete(true);
   undoState = 0;
   undoSteps = 50;
 
   pseudoModal = 0L;
   clear();
 
   setHighlight(0); //calls updateFontData()
   // if the user changes the highlight with the dialog, notify the doc
   connect(hlManager,SIGNAL(changed()),SLOT(hlChanged()));
 
   newDocGeometry = false;
 
   readConfig();
 
   setReadOnly(false);
 }
 
 void KateDocument::setDontChangeHlOnSave()
 {
   d(this)->hlSetByUser = true;
 }
 
 void KateDocument::setFont (QFont font)
 {
   kdDebug()<<"Kate:: setFont"<<endl;
   int oldwidth=myFontMetrics.width('W');  //Quick & Dirty Hack (by JoWenn) //Remove in KDE 3.0
   myFont = font;
   myFontBold = QFont (font);
   myFontBold.setBold (true);
 
   myFontItalic = QFont (font);
   myFontItalic.setItalic (true);
 
   myFontBI = QFont (font);
   myFontBI.setBold (true);
   myFontBI.setItalic (true);
 
   myFontMetrics = CachedFontMetrics (myFont);
   myFontMetricsBold = CachedFontMetrics (myFontBold);
   myFontMetricsItalic = CachedFontMetrics (myFontItalic);
   myFontMetricsBI = CachedFontMetrics (myFontBI);
   int newwidth=myFontMetrics.width('W'); //Quick & Dirty Hack (by JoWenn)  //Remove in KDE 3.0
   maxLength=maxLength*(float)newwidth/(float)oldwidth; //Quick & Dirty Hack (by JoWenn)  //Remove in KDE 3.0
 
   updateFontData();
   updateViews(); //Quick & Dirty Hack (by JoWenn) //Remove in KDE 3.0
 
 }
 
 long  KateDocument::needPreHighlight(long till)
 {
   int max=numLines()-1;
   if (till>max)
     {
       till=max;
     }
   if (PreHighlightedTill>=till) return -1;
 
   long tmp=RequestPreHighlightTill;
   if (RequestPreHighlightTill<till)
     {
       RequestPreHighlightTill=till;
       if (tmp<=PreHighlightedTill) QTimer::singleShot(10,this,SLOT(doPreHighlight()));
     }
   return RequestPreHighlightTill;
 }
 
 void KateDocument::doPreHighlight()
 {
   int from = PreHighlightedTill;
   int till = PreHighlightedTill+200;
   int max = numLines()-1;
   if (till > max)
     {
       till = max;
     }
   PreHighlightedTill = till;
   updateLines(from,till);
   emit preHighlightChanged(PreHighlightedTill);
   if (PreHighlightedTill<RequestPreHighlightTill)
     QTimer::singleShot(10,this,SLOT(doPreHighlight()));
 }
 
 KateDocument::~KateDocument()
 {
   m_highlight->release();
   writeConfig();
 
   if ( !m_bSingleViewMode )
   {
     m_views.setAutoDelete( true );
     m_views.clear();
     m_views.setAutoDelete( false );
   }
   delete_d(this);
 }
 
 void KateDocument::openURL(const QString &filename)
 {
 
   m_file=filename;  
   fileInfo->setFile (m_file);
   setMTime();
 
   if (!fileInfo->exists() || !fileInfo->isReadable())
   {
     qDebug("File doesn't exit or couldn't be read");
     return ;
   }
 
   buffer->clear();
 #warning fixme
 //  buffer->insertFile(0, m_file, KGlobal::charsets()->codecForName(myEncoding));
   qDebug("Telling buffer to open file");
   buffer->insertFile(0, m_file, QTextCodec::codecForLocale());
 
   setMTime();
 
   if (myWordWrap)
     wrapText (myWordWrapAt);
 
   int hl = hlManager->wildcardFind( m_file );
 
   setHighlight(hl);
 
   updateLines();
   updateViews();
 
   emit fileNameChanged();
   
   return ;
 }
 
 bool KateDocument::saveFile()
 {
     
   QFile f( m_file );
   if ( !f.open( IO_WriteOnly ) )
     return false; // Error
 
   QTextStream stream(&f);
 
   stream.setEncoding(QTextStream::RawUnicode); // disable Unicode headers
 #warning fixme
 //  stream.setCodec(KGlobal::charsets()->codecForName(myEncoding));
   stream.setCodec(QTextCodec::codecForLocale()); // this line sets the mapper to the correct codec
 
   int maxLine = numLines();
   int line = 0;
   while(true)
   {
     stream << getTextLine(line)->getString();
     line++;
     if (line >= maxLine) break;
 
     if (eolMode == KateDocument::eolUnix) stream << "\n";
     else if (eolMode == KateDocument::eolDos) stream << "\r\n";
     else if (eolMode == KateDocument::eolMacintosh) stream << '\r';
   };
   f.close();
 
   fileInfo->setFile (m_file);
   setMTime();
 
   if (!(d(this)->hlSetByUser))
   {
   int hl = hlManager->wildcardFind( m_file );
 
   setHighlight(hl);
   }
   emit fileNameChanged ();
 
   return (f.status() == IO_Ok);
 }
 
 KTextEditor::View *KateDocument::createView( QWidget *parent, const char *name )
 {
   return new KateView( this, parent, name);
 }
 
 QString KateDocument::textLine( int line ) const
 {
   TextLine::Ptr l = getTextLine( line );
   if ( !l )
     return QString();
 
   return l->getString();
 }
 
 void KateDocument::replaceLine(const QString& s,int line)
 {
   remove_Line(line,false);
   insert_Line(s,line,true);
 }
 
 void KateDocument::insertLine( const QString &str, int l ) {
   insert_Line(str,l,true);
 }
 
 void KateDocument::insert_Line(const QString& s,int line, bool update)
 {
   kdDebug(13020)<<"KateDocument::insertLine "<<s<<QString(" %1").arg(line)<<endl;
   TextLine::Ptr TL=new TextLine();
   TL->append(s.unicode(),s.length());
   buffer->insertLine(line,TL);
   if (update)
   {
     newDocGeometry=true;
     updateLines(line);
     updateViews();
   }
 }
 
 void KateDocument::insertAt( const QString &s, int line, int col, bool  )
 {
   VConfig c;
   c.view = 0; // ### FIXME
   c.cursor.x = col;
   c.cursor.y = line;
   c.cXPos = 0; // ### FIXME
   c.flags = 0; // ### FIXME
   insert( c, s );
 }
 
 void KateDocument::removeLine( int line ) {
   remove_Line(line,true);
 }
 
 void KateDocument::remove_Line(int line,bool update)
 {
   kdDebug(13020)<<"KateDocument::removeLine "<<QString("%1").arg(line)<<endl;
   buffer->removeLine(line);
 //  newDocGeometry=true;
 //  if line==0)
   if (update)
   {
     updateLines(line);
     updateViews();
   }
 }
 
 int KateDocument::length() const
 {
   return text().length();
 }
 
 void KateDocument::setSelection( int , int , int , int )
 {
 }
 
 bool KateDocument::hasSelection() const
 {
   return (selectEnd >= selectStart);
 }
 
 QString KateDocument::selection() const
diff --git a/noncore/apps/tinykate/libkate/kateconfig.cpp b/noncore/apps/tinykate/libkate/kateconfig.cpp
index 06ac49f..96f91fb 100644
--- a/noncore/apps/tinykate/libkate/kateconfig.cpp
+++ b/noncore/apps/tinykate/libkate/kateconfig.cpp
@@ -1,407 +1,405 @@
 /**********************************************************************
 ** Copyright (C) 2000 Trolltech AS.  All rights reserved.
 **
 ** This file is part of Qtopia Environment.
 **
 ** This file may be distributed and/or modified under the terms of the
 ** GNU General Public License version 2 as published by the Free Software
 ** Foundation and appearing in the file LICENSE.GPL included in the
 ** packaging of this file.
 **
 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
 **
 ** See http://www.trolltech.com/gpl/ for GPL licensing information.
 **
 ** Contact info@trolltech.com if any conditions of this licensing are
 ** not clear to you.
 **
 **********************************************************************/
 
 #include <qdir.h>
-#include <qfile.h>
-#include <qfileinfo.h>
 #include <qmessagebox.h>
 #if QT_VERSION <= 230 && defined(QT_NO_CODECS)
 #include <qtextcodec.h>
 #endif
 #include <qtextstream.h>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #include <unistd.h>
 
 #define QTOPIA_INTERNAL_LANGLIST
 #include "kateconfig.h"
 #include <qpe/global.h>
 
 
 /*!
   \internal
 */
 QString KateConfig::configFilename(const QString& name, Domain d)
 {
     switch (d) {
 	case File:
 	    return name;
 	case User: {
 	    QDir dir = (QString(getenv("HOME")) + "/Settings");
 	    if ( !dir.exists() )
 		mkdir(dir.path().local8Bit(),0700);
 	    return dir.path() + "/" + name + ".conf";
 	}
     }
     return name;
 }
 
 /*!
   \class KateConfig config.h
   \brief The KateConfig class provides for saving application cofniguration state.
 
   You should keep a KateConfig in existence only while you do not want others
   to be able to change the state. There is no locking currently, but there
   may be in the future.
 */
 
 /*!
   \enum KateConfig::KateConfigGroup
   \internal
 */
 
 /*!
   \enum KateConfig::Domain
 
   \value File
   \value User
 
   See KateConfig for details.
 */
 
 /*!
   Constructs a config that will load or create a configuration with the
   given \a name in the given \a domain.
 
   You must call setGroup() before doing much else with the KateConfig.
 
   In the default Domain, \e User,
   the configuration is user-specific. \a name should not contain "/" in
   this case, and in general should be the name of the C++ class that is
   primarily responsible for maintaining the configuration.
 
   In the File Domain, \a name is an absolute filename.
 */
 KateConfig::KateConfig( const QString &name, Domain domain )
     : filename( configFilename(name,domain) )
 {
     qWarning("KateConfig constructor\n");
     git = groups.end();
     read();
     QStringList l = Global::languageList();
     lang = l[0];
     glang = l[1];
 }
 
 
 // Sharp ROM compatibility
 KateConfig::KateConfig ( const QString &name, bool what )
 	: filename( configFilename(name,what ? User : File) )
 {
     git = groups.end();
     read();
     QStringList l = Global::languageList();
     lang = l[0];
     glang = l[1];
 }
 
 /*!
   Writes any changes to disk and destroys the in-memory object.
 */
 KateConfig::~KateConfig()
 {
     qWarning("KateConfig destructor\n");
     if ( changed )
 	write();
 }
 
 /*!
   Returns whether the current group has an entry called \a key.
 */
 bool KateConfig::hasKey( const QString &key ) const
 {
     if ( groups.end() == git )
 	return FALSE;
     KateConfigGroup::ConstIterator it = ( *git ).find( key );
     return it != ( *git ).end();
 }
 
 /*!
   Sets the current group for subsequent reading and writing of
   entries to \a gname. Grouping allows the application to partition the namespace.
 
   This function must be called prior to any reading or writing
   of entries.
 
   The \a gname must not be empty.
 */
 void KateConfig::setGroup( const QString &gname )
 {
     QMap< QString, KateConfigGroup>::Iterator it = groups.find( gname );
     if ( it == groups.end() ) {
 	git = groups.insert( gname, KateConfigGroup() );
 	changed = TRUE;
 	return;
     }
     git = it;
 }
 
 /*!
   Writes a (\a key, \a value) entry to the current group.
 
   \sa readEntry()
 */
 void KateConfig::writeEntry( const QString &key, const char* value )
 {
     writeEntry(key,QString(value));
 }
 
 /*!
   Writes a (\a key, \a value) entry to the current group.
 
   \sa readEntry()
 */
 void KateConfig::writeEntry( const QString &key, const QString &value )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     if ( (*git)[key] != value ) {
 	( *git ).insert( key, value );
 	changed = TRUE;
     }
 }
 
 /*
   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.
 */
 static QString 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;
 }
 
 static QString 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;
 }
 
 /*!
   Writes an encrypted (\a key, \a value) entry to the current group.
 
   Note that the degree of protection offered by the encryption is
   only sufficient to avoid the most casual observation of the configuration
   files.
 
   \sa readEntry()
 */
 void KateConfig::writeEntryCrypt( const QString &key, const QString &value )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     QString evalue = encipher(value);
     if ( (*git)[key] != evalue ) {
 	( *git ).insert( key, evalue );
 	changed = TRUE;
     }
 }
 
 /*!
   Writes a (\a key, \a num) entry to the current group.
 
   \sa readNumEntry()
 */
 void KateConfig::writeEntry( const QString &key, int num )
 {
     QString s;
     s.setNum( num );
     writeEntry( key, s );
 }
 
 void KateConfig::writeEntry( const QString &key, unsigned int num )
 {
     QString s;
     s.setNum( num );
     writeEntry( key, s );
 }
 
 #ifdef Q_HAS_BOOL_TYPE
 /*!
   Writes a (\a key, \a b) entry to the current group. This is equivalent
   to writing a 0 or 1 as an integer entry.
 
   \sa readBoolEntry()
 */
 void KateConfig::writeEntry( const QString &key, bool b )
 {
     QString s;
     s.setNum( ( int )b );
     writeEntry( key, s );
 }
 #endif
 
 /*!
   Writes a (\a key, \a lst) entry to the current group. The list
   is separated by \a sep, so the strings must not contain that character.
 
   \sa readListEntry()
 */
 void KateConfig::writeEntry( const QString &key, const QStringList &lst, const QChar &sep )
 {
     QString s;
     QStringList::ConstIterator it = lst.begin();
     for ( ; it != lst.end(); ++it )
 	s += *it + sep;
     writeEntry( key, s );
 }
 
 void KateConfig::writeEntry( const QString &key, const QColor &val )
 {
     QStringList l;
     l.append( QString().setNum(val.red()) );
     l.append( QString().setNum(val.green()) );
     l.append( QString().setNum(val.blue()) );
     
     writeEntry( key, l, QChar(',') );
 }
 
 void KateConfig::writeEntry( const QString &key, const QFont &val )
 {
     QStringList l;
     l.append( val.family() );
     l.append( QString().setNum(val.pointSize()) );
     l.append( QString().setNum(val.weight()) );
     l.append( QString().setNum((int)val.italic()) );
     l.append( QString().setNum((int)val.charSet()) );
     
     writeEntry( key, l, QChar(',') );
 }
 
 /*!
   Removes the \a key entry from the current group. Does nothing if
   there is no such entry.
 */
 
 void KateConfig::removeEntry( const QString &key )
 {
     if ( git == groups.end() ) {
 	qWarning( "no group set" );
 	return;
     }
     ( *git ).remove( key );
     changed = TRUE;
 }
 
 /*!
   \fn bool KateConfig::operator == ( const KateConfig & other ) const
 
   Tests for equality with \a other. KateConfig objects are equal if they refer to the same filename.
 */
 
 /*!
   \fn bool KateConfig::operator != ( const KateConfig & other ) const
 
   Tests for inequality with \a other. KateConfig objects are equal if they refer to the same filename.
 */
 
 /*!
   \fn QString KateConfig::readEntry( const QString &key, const QString &deflt ) const
 
   Reads a string entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString KateConfig::readEntry( const QString &key, const QString &deflt )
 {
     QString res = readEntryDirect( key+"["+lang+"]" );
     if ( !res.isNull() )
 	return res;
     if ( !glang.isEmpty() ) {
 	res = readEntryDirect( key+"["+glang+"]" );
 	if ( !res.isNull() )
 	    return res;
     }
     return readEntryDirect( key, deflt );
 }
 
 /*!
   \fn QString KateConfig::readEntryCrypt( const QString &key, const QString &deflt ) const
 
   Reads an encrypted string entry stored with \a key, defaulting to \a deflt if there is no entry.
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString KateConfig::readEntryCrypt( const QString &key, const QString &deflt )
 {
     QString res = readEntryDirect( key+"["+lang+"]" );
     if ( res.isNull() && glang.isEmpty() )
 	res = readEntryDirect( key+"["+glang+"]" );
     if ( res.isNull() )
 	res = readEntryDirect( key, QString::null );
     if ( res.isNull() )
 	return deflt;
     return decipher(res);
 }
 
 /*!
   \fn QString KateConfig::readEntryDirect( const QString &key, const QString &deflt ) const
   \internal
 */
 
 /*!
   \internal
   For compatibility, non-const version.
 */
 QString KateConfig::readEntryDirect( const QString &key, const QString &deflt )
 {
     if ( git == groups.end() ) {
 	//qWarning( "no group set" );
 	return deflt;
     }
     KateConfigGroup::ConstIterator it = ( *git ).find( key );
     if ( it != ( *git ).end() )
 	return *it;
diff --git a/noncore/apps/tinykate/libkate/view/kateview.cpp b/noncore/apps/tinykate/libkate/view/kateview.cpp
index 794fbdb..423634b 100644
--- a/noncore/apps/tinykate/libkate/view/kateview.cpp
+++ b/noncore/apps/tinykate/libkate/view/kateview.cpp
@@ -1,468 +1,461 @@
 /***************************************************************************
                           kateview.cpp  -  description
                              -------------------
     begin                : Mon Jan 15 2001
     copyright            : (C) 2001 by Christoph "Crossfire" Cullmann
          (C) 2002 by Joseph Wenninger
     email                : crossfire@babylon2k.de
          jowenn@kde.org
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 
 /*
    Copyright (C) 1998, 1999 Jochen Wilhelmy
                             digisnap@cs.tu-berlin.de
 
     This library is free software; you can redistribute it and/or
     modify it under the terms of the GNU Library General Public
     License as published by the Free Software Foundation; either
     version 2 of the License, or (at your option) any later version.
 
     This library is distributed in the hope that it will be useful,
     but WITHOUT ANY WARRANTY; without even the implied warranty of
     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     Library General Public License for more details.
 
     You should have received a copy of the GNU Library General Public License
     along with this library; see the file COPYING.LIB.  If not, write to
     the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
     Boston, MA 02111-1307, USA.
 */
 
 
 
 #include "kateview.h"
 
 #include "../document/katedocument.h"
 #include "../document/katecmd.h"
 #include "../document/katehighlight.h"
-#include "kateviewdialog.h"
 #include "../document/katedialogs.h"
+#include "kateviewdialog.h"
 #include <kateconfig.h>
 
-#include <qfocusdata.h>
-#include <kdebug.h>
 #include <kapplication.h>
 #include <qscrollbar.h>
-#include <qiodevice.h>
 #include <qpopupmenu.h>
 #include <kpopupmenu.h>
 #include <qkeycode.h>
 #include <qintdict.h>
 #include <qfont.h>
 #include <qpainter.h>
 #include <qpixmap.h>
 #include <qfileinfo.h>
 #include <qfile.h>
 #include <qevent.h>
 #include <qdir.h>
 #include <qvbox.h>
 #include <qprintdialog.h>
 #include <qpaintdevicemetrics.h>
-#include <qiodevice.h>
 #include <qbuffer.h>
-#include <qfocusdata.h>
 #include <klocale.h>
 #include <kglobal.h>
-#include <kdebug.h>
 #include <kmessagebox.h>
 #include <qregexp.h>
 #include <kdialogbase.h>
 #include <klineeditdlg.h>
 #include <qapplication.h>
 #include <kfiledialog.h>
 #include <kiconloader.h>
 #include "../document/katetextline.h"
-#include "kateviewdialog.h"
 #include "kateundohistory.h"
 #include <qlayout.h>
 #include <qpe/qpeapplication.h>
 
 KateViewInternal::KateViewInternal(KateView *view, KateDocument *doc) : QWidget(view)
 {
   waitForPreHighlight=-1;
   myView = view;
   myDoc = doc;
 
   iconBorderWidth  = 16;
   iconBorderHeight = 800;
 
   QWidget::setCursor(ibeamCursor);
   setBackgroundMode(NoBackground);
 
   setFocusPolicy(StrongFocus);
 
   xScroll = new QScrollBar(QScrollBar::Horizontal,myView);
   yScroll = new QScrollBar(QScrollBar::Vertical,myView);
   connect(xScroll,SIGNAL(valueChanged(int)),SLOT(changeXPos(int)));
   connect(yScroll,SIGNAL(valueChanged(int)),SLOT(changeYPos(int)));
   connect(yScroll,SIGNAL(valueChanged(int)),myView,SIGNAL(scrollValueChanged(int)));
   connect( doc, SIGNAL (preHighlightChanged(long)),this,SLOT(slotPreHighlightUpdate(long)));
 
   xPos = 0;
   yPos = 0;
 
   scrollTimer = 0;
 
   cursor.x = 0;
   cursor.y = 0;
   cursorOn = false;
   cursorTimer = 0;
   cXPos = 0;
   cOldXPos = 0;
 
   startLine = 0;
   endLine = -1;
 
   exposeCursor = false;
   updateState = 0;
   numLines = 0;
   lineRanges = 0L;
   newXPos = -1;
   newYPos = -1;
 
   drawBuffer = new QPixmap ();
   drawBuffer->setOptimization (QPixmap::BestOptim);
 
   bm.sXPos = 0;
   bm.eXPos = -1;
 
 }
 
 
 KateViewInternal::~KateViewInternal()
 {
   delete [] lineRanges;
   delete drawBuffer;
 }
 
 
 void KateViewInternal::slotPreHighlightUpdate(long line)
 {
   //kdDebug()<<QString("slotPreHighlightUpdate - Wait for: %1, line:  %2").arg(waitForPreHighlight).arg(line)<<endl;
   if (waitForPreHighlight!=-1)
     {
        if (line>=waitForPreHighlight)
          {
            waitForPreHighlight=-1;
            repaint();
          }
     }
 }
 
 void KateViewInternal::doCursorCommand(VConfig &c, int cmdNum) {
 
   switch (cmdNum) {
     case KateView::cmLeft:
       cursorLeft(c);
       break;
     case KateView::cmRight:
       cursorRight(c);
       break;
     case KateView::cmWordLeft:
       wordLeft(c);
       break;
     case KateView::cmWordRight:
       wordRight(c);
       break;
     case KateView::cmHome:
       home(c);
       break;
     case KateView::cmEnd:
       end(c);
       break;
     case KateView::cmUp:
       cursorUp(c);
       break;
     case KateView::cmDown:
       cursorDown(c);
       break;
     case KateView::cmScrollUp:
       scrollUp(c);
       break;
     case KateView::cmScrollDown:
       scrollDown(c);
       break;
     case KateView::cmTopOfView:
       topOfView(c);
       break;
     case KateView::cmBottomOfView:
       bottomOfView(c);
       break;
     case KateView::cmPageUp:
       pageUp(c);
       break;
     case KateView::cmPageDown:
       pageDown(c);
       break;
     case KateView::cmTop:
       top_home(c);
       break;
     case KateView::cmBottom:
       bottom_end(c);
       break;
   }
 }
 
 void KateViewInternal::doEditCommand(VConfig &c, int cmdNum) {
 
   switch (cmdNum) {
     case KateView::cmCopy:
       myDoc->copy(c.flags);
       return;
     case KateView::cmSelectAll:
       myDoc->selectAll();
       return;
     case KateView::cmDeselectAll:
       myDoc->deselectAll();
       return;
     case KateView::cmInvertSelection:
       myDoc->invertSelection();
       return;
   }
   if (myView->isReadOnly()) return;
   switch (cmdNum) {
     case KateView::cmReturn:
       if (c.flags & KateView::cfDelOnInput) myDoc->delMarkedText(c);
       myDoc->newLine(c);
       //emit returnPressed();
       //e->ignore();
       return;
     case KateView::cmDelete:
       if ((c.flags & KateView::cfDelOnInput) && myDoc->hasMarkedText())
         myDoc->delMarkedText(c);
       else myDoc->del(c);
       return;
     case KateView::cmBackspace:
       if ((c.flags & KateView::cfDelOnInput) && myDoc->hasMarkedText())
         myDoc->delMarkedText(c);
       else myDoc->backspace(c);
       return;
     case KateView::cmKillLine:
       myDoc->killLine(c);
       return;
     case KateView::cmCut:
       myDoc->cut(c);
       return;
     case KateView::cmPaste:
       if (c.flags & KateView::cfDelOnInput) myDoc->delMarkedText(c);
       myDoc->paste(c);
       return;
     case KateView::cmUndo:
       myDoc->undo(c);
       return;
     case KateView::cmRedo:
       myDoc->redo(c);
       return;
     case KateView::cmIndent:
       myDoc->indent(c);
       return;
     case KateView::cmUnindent:
       myDoc->unIndent(c);
       return;
     case KateView::cmCleanIndent:
       myDoc->cleanIndent(c);
       return;
     case KateView::cmComment:
       myDoc->comment(c);
       return;
     case KateView::cmUncomment:
       myDoc->unComment(c);
       return;
   }
 }
 
 void KateViewInternal::cursorLeft(VConfig &c) {
 
   cursor.x--;
   if (c.flags & KateView::cfWrapCursor && cursor.x < 0 && cursor.y > 0) {
     cursor.y--;
     cursor.x = myDoc->textLength(cursor.y);
   }
   cOldXPos = cXPos = myDoc->textWidth(cursor);
   changeState(c);
 }
 
 void KateViewInternal::cursorRight(VConfig &c) {
 
   if (c.flags & KateView::cfWrapCursor) {
     if (cursor.x >= myDoc->textLength(cursor.y)) {
       if (cursor.y == myDoc->lastLine()) return;
       cursor.y++;
       cursor.x = -1;
     }
   }
   cursor.x++;
   cOldXPos = cXPos = myDoc->textWidth(cursor);
   changeState(c);
 }
 
 void KateViewInternal::wordLeft(VConfig &c) {
   Highlight *highlight;
 
   highlight = myDoc->highlight();
   TextLine::Ptr textLine = myDoc->getTextLine(cursor.y);
 
   if (cursor.x > 0) {
     do {
       cursor.x--;
     } while (cursor.x > 0 && !highlight->isInWord(textLine->getChar(cursor.x)));
     while (cursor.x > 0 && highlight->isInWord(textLine->getChar(cursor.x -1)))
       cursor.x--;
   } else {
     if (cursor.y > 0) {
       cursor.y--;
       textLine = myDoc->getTextLine(cursor.y);
       cursor.x = textLine->length();
     }
   }
 
   cOldXPos = cXPos = myDoc->textWidth(cursor);
   changeState(c);
 }
 
 void KateViewInternal::wordRight(VConfig &c) {
   Highlight *highlight;
   int len;
 
   highlight = myDoc->highlight();
   TextLine::Ptr textLine = myDoc->getTextLine(cursor.y);
   len = textLine->length();
 
   if (cursor.x < len) {
     do {
       cursor.x++;
     } while (cursor.x < len && highlight->isInWord(textLine->getChar(cursor.x)));
     while (cursor.x < len && !highlight->isInWord(textLine->getChar(cursor.x)))
       cursor.x++;
   } else {
     if (cursor.y < myDoc->lastLine()) {
       cursor.y++;
       textLine = myDoc->getTextLine(cursor.y);
       cursor.x = 0;
     }
   }
 
   cOldXPos = cXPos = myDoc->textWidth(cursor);
   changeState(c);
 }
 
 void KateViewInternal::home(VConfig &c) {
   int lc;
 
   lc = (c.flags & KateView::cfSmartHome) ? myDoc->getTextLine(cursor.y)->firstChar() : 0;
   if (lc <= 0 || cursor.x == lc) {
     cursor.x = 0;
     cOldXPos = cXPos = 0;
   } else {
     cursor.x = lc;
     cOldXPos = cXPos = myDoc->textWidth(cursor);
   }
 
   changeState(c);
 }
 
 void KateViewInternal::end(VConfig &c) {
   cursor.x = myDoc->textLength(cursor.y);
   cOldXPos = cXPos = myDoc->textWidth(cursor);
   changeState(c);
 }
 
 
 void KateViewInternal::cursorUp(VConfig &c) {
 
   cursor.y--;
   cXPos = myDoc->textWidth(c.flags & KateView::cfWrapCursor,cursor,cOldXPos);
   changeState(c);
 }
 
 
 void KateViewInternal::cursorDown(VConfig &c) {
   int x;
 
   if (cursor.y == myDoc->lastLine()) {
     x = myDoc->textLength(cursor.y);
     if (cursor.x >= x) return;
     cursor.x = x;
     cXPos = myDoc->textWidth(cursor);
   } else {
     cursor.y++;
     cXPos = myDoc->textWidth(c.flags & KateView::cfWrapCursor, cursor, cOldXPos);
   }
   changeState(c);
 }
 
 void KateViewInternal::scrollUp(VConfig &c) {
 
   if (! yPos) return;
 
   newYPos = yPos - myDoc->fontHeight;
   if (cursor.y == (yPos + height())/myDoc->fontHeight -1) {
     cursor.y--;
     cXPos = myDoc->textWidth(c.flags & KateView::cfWrapCursor,cursor,cOldXPos);
 
     changeState(c);
   }
 }
 
 void KateViewInternal::scrollDown(VConfig &c) {
 
   if (endLine >= myDoc->lastLine()) return;
 
   newYPos = yPos + myDoc->fontHeight;
   if (cursor.y == (yPos + myDoc->fontHeight -1)/myDoc->fontHeight) {
     cursor.y++;
     cXPos = myDoc->textWidth(c.flags & KateView::cfWrapCursor,cursor,cOldXPos);
     changeState(c);
   }
 }
 
 void KateViewInternal::topOfView(VConfig &c) {
 
   cursor.y = (yPos + myDoc->fontHeight -1)/myDoc->fontHeight;
   cursor.x = 0;
   cOldXPos = cXPos = 0;
   changeState(c);
 }
 
 void KateViewInternal::bottomOfView(VConfig &c) {
 
   cursor.y = (yPos + height())/myDoc->fontHeight -1;
   if (cursor.y < 0) cursor.y = 0;
   if (cursor.y > myDoc->lastLine()) cursor.y = myDoc->lastLine();
   cursor.x = 0;
   cOldXPos = cXPos = 0;
   changeState(c);
 }
 
 void KateViewInternal::pageUp(VConfig &c) {
   int lines = (endLine - startLine - 1);
 
   if (lines <= 0) lines = 1;
 
   if (!(c.flags & KateView::cfPageUDMovesCursor) && yPos > 0) {
     newYPos = yPos - lines * myDoc->fontHeight;
     if (newYPos < 0) newYPos = 0;
   }
   cursor.y -= lines;
   cXPos = myDoc->textWidth(c.flags & KateView::cfWrapCursor, cursor, cOldXPos);
   changeState(c);
 //  cursorPageUp(c);
 }
 
 void KateViewInternal::pageDown(VConfig &c) {
 
   int lines = (endLine - startLine - 1);
 
   if (!(c.flags & KateView::cfPageUDMovesCursor) && endLine < myDoc->lastLine()) {
     if (lines < myDoc->lastLine() - endLine)
       newYPos = yPos + lines * myDoc->fontHeight;
     else
diff --git a/noncore/apps/tinykate/libkate/view/kateviewdialog.cpp b/noncore/apps/tinykate/libkate/view/kateviewdialog.cpp
index bd5b74f..a85fb87 100644
--- a/noncore/apps/tinykate/libkate/view/kateviewdialog.cpp
+++ b/noncore/apps/tinykate/libkate/view/kateviewdialog.cpp
@@ -1,428 +1,426 @@
 /***************************************************************************
                           kateviewdialog.cpp  -  description
                              -------------------
     copyright            : (C) 2001 by The Kate Team
                            (C) 2002 by Joseph Wenninger
     email                : kwrite-devel@kde.org
                            jowenn@kde.org
 
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 // Dialogs
 
 #include <stdio.h>
 #include <stdlib.h>
 
 #include <qgrid.h>
 #include <qlabel.h>
 #include <qlayout.h>
 #include <qlistbox.h>
-#include <qspinbox.h>
-#include <qcombobox.h>
 #include <qgroupbox.h>
 #include <qlineedit.h>
 #include <qcheckbox.h>
 #include <qcollection.h>
 #include <qpushbutton.h>
 #include <qobjectlist.h>
 #include <qradiobutton.h>
 #include <qwhatsthis.h>
 #include <qstringlist.h>
 #include <klocale.h>
 #include <kcolorbtn.h>
-#include <qcombobox.h>
 #include <kglobal.h>
 #include <qvbox.h>
 #include <qspinbox.h>
+#include <qcombobox.h>
 #include <kfontdialog.h>
 
 #include "../document/katedocument.h"
 #include "kateviewdialog.h"
 #include <opie2/ofontselector.h>
 
 
 SearchDialog::SearchDialog( QWidget *parent, QStringList &searchFor, QStringList &replaceWith, int flags )
   : KDialogBase( parent, 0L, true, i18n( "Find Text" ), Ok | Cancel, Ok )
   , m_replace( 0L )
 {
   QWidget *page = new QWidget( this );
   setMainWidget( page );
 
   QVBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
 
   m_search = new QComboBox( true, page );
   m_search->insertStringList( searchFor );
   m_search->setMinimumWidth( m_search->sizeHint().width() );
   m_search->lineEdit()->selectAll();
   QLabel *label = new QLabel( m_search, i18n( "&Text To Find:" ), page );
   m_optRegExp = new QCheckBox( i18n( "Regular Expression" ), page );
   topLayout->addWidget( label );
   topLayout->addWidget( m_search );
   topLayout->addWidget( m_optRegExp );
 
   if( flags & KateView::sfReplace )
   {
     // make it a replace dialog
     setCaption( i18n( "Replace Text" ) );
     m_replace = new QComboBox( true, page );
     m_replace->insertStringList( replaceWith );
     m_replace->setMinimumWidth( m_search->sizeHint().width() );
     label = new QLabel( m_replace, i18n( "&Replace With:" ), page );
     //m_optPlaceholders = new QCheckBox( i18n( "&Use Placeholders" ), page );
     topLayout->addWidget( label );
     topLayout->addWidget( m_replace );
     //topLayout->addWidget( m_optPlaceholders );
   }
 
   QGroupBox *group = new QGroupBox( i18n( "Options" ), page );
   topLayout->addWidget( group, 10 );
 
   QGridLayout *gbox = new QGridLayout( group, 5, 2, spacingHint() );
   gbox->addRowSpacing( 0, fontMetrics().lineSpacing() );
   gbox->setRowStretch( 4, 10 );
 
   m_opt1 = new QCheckBox( i18n( "C&ase Sensitive" ), group );
   gbox->addWidget( m_opt1, 1, 0 );
 
   m_opt2 = new QCheckBox(i18n("&Whole Words Only" ), group );
   gbox->addWidget( m_opt2, 2, 0 );
 
   m_opt3 = new QCheckBox(i18n("&From Beginning" ), group );
   gbox->addWidget( m_opt3, 3, 0 );
 
   m_opt4 = new QCheckBox(i18n("Find &Backwards" ), group );
   gbox->addWidget( m_opt4, 1, 1 );
 
   m_opt5 = new QCheckBox(i18n("&Selected Text" ), group );
   gbox->addWidget( m_opt5, 2, 1 );
 
   m_opt1->setChecked( flags & KateView::sfCaseSensitive );
   m_opt2->setChecked( flags & KateView::sfWholeWords );
   m_opt3->setChecked( flags & KateView::sfFromBeginning );
   m_optRegExp->setChecked( flags & KateView::sfRegularExpression );
   m_opt4->setChecked( flags & KateView::sfBackward );
   m_opt5->setChecked( flags & KateView::sfSelected );
 
   if( m_replace )
   {
     m_opt6 = new QCheckBox( i18n( "&Prompt On Replace" ), group );
     m_opt6->setChecked( flags & KateView::sfPrompt );
     gbox->addWidget( m_opt6, 3, 1 );
   }
 
   m_search->setFocus();
 }
 
 QString SearchDialog::getSearchFor()
 {
   return m_search->currentText();
 }
 
 QString SearchDialog::getReplaceWith()
 {
   return m_replace->currentText();
 }
 
 int SearchDialog::getFlags()
 {
   int flags = 0;
 
   if( m_opt1->isChecked() ) flags |= KateView::sfCaseSensitive;
   if( m_opt2->isChecked() ) flags |= KateView::sfWholeWords;
   if( m_opt3->isChecked() ) flags |= KateView::sfFromBeginning;
   if( m_opt4->isChecked() ) flags |= KateView::sfBackward;
   if( m_opt5->isChecked() ) flags |= KateView::sfSelected;
   if( m_optRegExp->isChecked() ) flags |= KateView::sfRegularExpression;
   if( m_replace )
   {
     if( m_opt6->isChecked() )
       flags |= KateView::sfPrompt;
 
     flags |= KateView::sfReplace;
   }
 
   return flags;
 }
 
 void SearchDialog::slotOk()
 {
   if ( !m_search->currentText().isEmpty() )
   {
     if ( !m_optRegExp->isChecked() )
     {
       accept();
     }
     else
     {
       // Check for a valid regular expression.
 
       QRegExp regExp( m_search->currentText() );
 
       if ( regExp.isValid() )
         accept();
     }
   }
 }
 
 void SearchDialog::setSearchText( const QString &searchstr )
  {
    m_search->insertItem( searchstr, 0 );
    m_search->setCurrentItem( 0 );
    m_search->lineEdit()->selectAll();
  }
 
 // this dialog is not modal
 ReplacePrompt::ReplacePrompt( QWidget *parent )
   : KDialogBase(parent, 0L, false, i18n( "Replace Text" ),
   User3 | User2 | User1 | Close, User3, true,
   i18n("&All"), i18n("&No"), i18n("&Yes")) {
 
   QWidget *page = new QWidget(this);
   setMainWidget(page);
 
   QBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
   QLabel *label = new QLabel(i18n("Replace this occurence?"),page);
   topLayout->addWidget(label );
 }
 
 void ReplacePrompt::slotUser1( void ) { // All
   done(KateView::srAll);
 }
 
 void ReplacePrompt::slotUser2( void ) { // No
   done(KateView::srNo);
 }
 
 void ReplacePrompt::slotUser3( void ) { // Yes
   accept();
 }
 
 void ReplacePrompt::done(int r) {
   setResult(r);
   emit clicked();
 }
 
 void ReplacePrompt::closeEvent(QCloseEvent *) {
   reject();
 }
 
 GotoLineDialog::GotoLineDialog(QWidget *parent, int line, int max)
   : KDialogBase(parent, 0L, true, i18n("Goto Line"), Ok | Cancel, Ok) {
 
   QWidget *page = new QWidget(this);
   setMainWidget(page);
 
   QVBoxLayout *topLayout = new QVBoxLayout( page, 0, spacingHint() );
   e1 = new QSpinBox(page);
   e1->setMinValue(1);
   e1->setMaxValue(max);
   e1->setValue((int)line);
 
   QLabel *label = new QLabel( e1,i18n("&Goto Line:"), page );
   topLayout->addWidget(label);
   topLayout->addWidget(e1);
   topLayout->addSpacing(spacingHint()); // A little bit extra space
   topLayout->addStretch(10);
   e1->setFocus();
 }
 
 int GotoLineDialog::getLine() {
   return e1->value();
 }
 
 const int IndentConfigTab::flags[] = {KateView::cfAutoIndent, KateView::cfSpaceIndent,
   KateView::cfBackspaceIndents,KateView::cfTabIndents, KateView::cfKeepIndentProfile, KateView::cfKeepExtraSpaces};
 
 IndentConfigTab::IndentConfigTab(QWidget *parent, KateView *view)
   : QWidget(parent, 0L)
 {
   QVBoxLayout *layout = new QVBoxLayout(this, 0, KDialog::spacingHint() );
   int configFlags = view->config();
 
   opt[0] = new QCheckBox(i18n("&Auto Indent"), this);
   layout->addWidget(opt[0], 0, AlignLeft);
   opt[0]->setChecked(configFlags & flags[0]);
 
   opt[1] = new QCheckBox(i18n("Indent With &Spaces"), this);
   layout->addWidget(opt[1], 0, AlignLeft);
   opt[1]->setChecked(configFlags & flags[1]);
 
   opt[2] = new QCheckBox(i18n("&Backspace Key Indents"), this);
   layout->addWidget(opt[2], 0, AlignLeft);
   opt[2]->setChecked(configFlags & flags[2]);
 
   opt[3] = new QCheckBox(i18n("&Tab Key Indents"), this);
   layout->addWidget(opt[3], 0, AlignLeft);
   opt[3]->setChecked(configFlags & flags[3]);
 
   opt[4] = new QCheckBox(i18n("Keep Indent &Profile"), this);
   layout->addWidget(opt[4], 0, AlignLeft);
 //  opt[4]->setChecked(configFlags & flags[4]);
   opt[4]->setChecked(true);
   opt[4]->hide();
 
   opt[5] = new QCheckBox(i18n("&Keep Extra Spaces"), this);
   layout->addWidget(opt[5], 0, AlignLeft);
   opt[5]->setChecked(configFlags & flags[5]);
 
   layout->addStretch();
 
   // What is this? help
   QWhatsThis::add(opt[0], i18n("When <b>Auto indent</b> is on, KateView will indent new lines to equal the indent on the previous line.<p>If the previous line is blank, the nearest line above with text is used"));
   QWhatsThis::add(opt[1], i18n("Check this if you want to indent with spaces rather than tabs.<br>A Tab will be converted to <u>Tab-width</u> as set in the <b>edit</b> options"));
   QWhatsThis::add(opt[2], i18n("This allows the <b>backspace</b> key to be used to indent."));
   QWhatsThis::add(opt[3], i18n("This allows the <b>tab</b> key to be used to indent."));
   QWhatsThis::add(opt[4], i18n("This retains current indentation settings for future documents."));
   QWhatsThis::add(opt[5], i18n("Indentations of more than the selected number of spaces will not be shortened."));
 }
 
 void IndentConfigTab::getData(KateView *view) {
   int configFlags, z;
 
   configFlags = view->config();
   for (z = 0; z < numFlags; z++) {
     configFlags &= ~flags[z];
     if (opt[z]->isChecked()) configFlags |= flags[z];
   }
   view->setConfig(configFlags);
 }
 
 const int SelectConfigTab::flags[] = {KateView::cfPersistent, KateView::cfDelOnInput,
   KateView::cfMouseAutoCopy, KateView::cfSingleSelection, KateView::cfVerticalSelect, KateView::cfXorSelect};
 
 SelectConfigTab::SelectConfigTab(QWidget *parent, KateView *view)
   : QWidget(parent, 0L)
 {
   QVBoxLayout *layout = new QVBoxLayout(this, 0, KDialog::spacingHint() );
   int configFlags = view->config();
 
   opt[0] = new QCheckBox(i18n("&Persistent Selections"), this);
   layout->addWidget(opt[0], 0, AlignLeft);
   opt[0]->setChecked(configFlags & flags[0]);
 
   opt[1] = new QCheckBox(i18n("&Overwrite Selections"), this);
   layout->addWidget(opt[1], 0, AlignLeft);
   opt[1]->setChecked(configFlags & flags[1]);
 
   opt[2] = new QCheckBox(i18n("Mouse &Autocopy"), this);
   layout->addWidget(opt[2], 0, AlignLeft);
   opt[2]->setChecked(configFlags & flags[2]);
 
   opt[3] = new QCheckBox(i18n("&X11-like Single Selection"), this);
   layout->addWidget(opt[3], 0, AlignLeft);
   opt[3]->setChecked(configFlags & flags[3]);
 
   opt[4] = new QCheckBox(i18n("&Vertical Selections"), this);
   layout->addWidget(opt[4], 0, AlignLeft);
   opt[4]->setChecked(configFlags & flags[4]);
 
   opt[5] = new QCheckBox(i18n("&Toggle Old"), this);
   layout->addWidget(opt[5], 0, AlignLeft);
   opt[5]->setChecked(configFlags & flags[5]);
 
   layout->addStretch();
 
   // What is this? help
   QWhatsThis::add(opt[0], i18n("Enabling this prevents key input or cursor movement by way of the arrow keys from causing the elimination of text selection.<p><b>Note:</b> If the Overwrite Selections option is activated then any typed character input or paste operation will replace the selected text."));
   QWhatsThis::add(opt[1], i18n("When this is on, any keyed character input or paste operation will replace the selected text."));
   QWhatsThis::add(opt[2], i18n("When this is on, any text selected with the mouse will be automatically copied to the clipboard."));
   QWhatsThis::add(opt[3], i18n("Not implemented yet."));
   QWhatsThis::add(opt[4], i18n("Enabling this allows you to make vertical selections."));
   QWhatsThis::add(opt[5], i18n("Not yet implemented."));
 }
 
 void SelectConfigTab::getData(KateView *view) {
   int configFlags, z;
 
   configFlags = view->config();
   for (z = 0; z < numFlags; z++) {
     configFlags &= ~flags[z]; // clear flag
     if (opt[z]->isChecked()) configFlags |= flags[z]; // set flag if checked
   }
   view->setConfig(configFlags);
 }
 
 const int EditConfigTab::flags[] = {KateView::cfWordWrap, KateView::cfReplaceTabs, KateView::cfRemoveSpaces,
   KateView::cfAutoBrackets, KateView::cfGroupUndo, KateView::cfShowTabs, KateView::cfSmartHome,
   KateView::cfPageUDMovesCursor, KateView::cfWrapCursor};
 
 EditConfigTab::EditConfigTab(QWidget *parent, KateView *view)
   : QWidget(parent, 0L) {
 
   QHBoxLayout *mainLayout;
   QVBoxLayout *cbLayout, *leLayout;
   int configFlags;
 
   mainLayout = new QHBoxLayout(this, 0, KDialog::spacingHint() );
 
   // checkboxes
   cbLayout = new QVBoxLayout( mainLayout );
   configFlags = view->config();
 
   opt[0] = new QCheckBox(i18n("&Word wrap"), this);
   cbLayout->addWidget(opt[0], 0, AlignLeft);
   opt[0]->setChecked(view->doc()->wordWrap());
 
   opt[1] = new QCheckBox(i18n("Replace &tabs with spaces"), this);
   cbLayout->addWidget(opt[1], 0, AlignLeft);
   opt[1]->setChecked(configFlags & flags[1]);
 
   opt[2] = new QCheckBox(i18n("&Remove trailing spaces"), this);
   cbLayout->addWidget(opt[2], 0, AlignLeft);
   opt[2]->setChecked(configFlags & flags[2]);
 
   opt[3] = new QCheckBox(i18n("&Auto brackets"), this);
   cbLayout->addWidget(opt[3], 0, AlignLeft);
   opt[3]->setChecked(configFlags & flags[3]);
 
   opt[4] = new QCheckBox(i18n("Group &undos"), this);
   cbLayout->addWidget(opt[4], 0, AlignLeft);
   opt[4]->setChecked(configFlags & flags[4]);
 
   opt[5] = new QCheckBox(i18n("&Show tabs"), this);
   cbLayout->addWidget(opt[5], 0, AlignLeft);
   opt[5]->setChecked(configFlags & flags[5]);
 
   opt[6] = new QCheckBox(i18n("Smart &home"), this);
   cbLayout->addWidget(opt[6], 0, AlignLeft);
   opt[6]->setChecked(configFlags & flags[6]);
 
   opt[7] = new QCheckBox(i18n("&Page up/down moves cursor"), this);
   cbLayout->addWidget(opt[7], 0, AlignLeft);
   opt[7]->setChecked(configFlags & flags[7]);
 
   opt[8] = new QCheckBox(i18n("Wrap &cursor"), this);
   cbLayout->addWidget(opt[8], 0, AlignLeft);
   opt[8]->setChecked(configFlags & flags[8]);
 
   cbLayout->addStretch();
 
   // edit lines
   leLayout = new QVBoxLayout();
   mainLayout->addLayout(leLayout,10);
 
   e1 = new QSpinBox(this);
   e1->setMinValue(20);
   e1->setMaxValue( 200);
   e1->setValue((int)(view->doc()->wordWrapAt()));
 #warning fixme  e1->setLabel(i18n("Wrap Words At:"));
 
   e2 = new QSpinBox(this);
   e2->setMinValue(1);
   e2->setMaxValue(16);
   e2->setValue((int)view->tabWidth());
 
 #warning fixme  e2->setLabel(i18n("Tab/Indent Width:"));
 
   e3 = new QSpinBox(this);
   e3->setMinValue(5);
   e3->setMaxValue( 30000);
 #warning fixme   e3->setLabel(i18n("Undo steps:"));
diff --git a/noncore/apps/tinykate/tinykate.cpp b/noncore/apps/tinykate/tinykate.cpp
index bbf80ce..19a0127 100644
--- a/noncore/apps/tinykate/tinykate.cpp
+++ b/noncore/apps/tinykate/tinykate.cpp
@@ -1,283 +1,278 @@
 /***************************************************************************
                              tinykate.cpp
                         Tiny KATE mainwindow
                              -------------------
     begin                : November 2002
     copyright            : (C) 2002 by Joseph Wenninger <jowenn@kde.org>
  ***************************************************************************/
 
 /***************************************************************************
  *                                                                         *
  *   This program is free softwaSre; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation.                                         *
  *   ONLY VERSION 2 OF THE LICENSE IS APPLICABLE                           *
  *                                                                         *
  ***************************************************************************/
-#include <qwidget.h>
 #include <qaction.h>
-#include <qlayout.h>
 #include <qtoolbutton.h>
 #include <qmenubar.h>
 #include <qpe/resource.h>
-#include <qpe/global.h>
 #include <qpe/qpeapplication.h>
 
 #include <opie2/ofiledialog.h>
 
 #include "tinykate.h"
 
 #include <katedocument.h>
-#include <katehighlight.h>
-#include <kateview.h>
 #include <kglobal.h>
 
 TinyKate::TinyKate( QWidget *parent, const char *name, WFlags f) :
     QMainWindow( parent, name, f )
 {
   shutDown=false;
   nextUnnamed=0;
   currentView=0;
   viewCount=0;
   setCaption(tr("TinyKATE"));
   KGlobal::setAppName("TinyKATE");
 
   QMenuBar *mb = new QMenuBar( this );
   mb->setMargin( 0 );
 
   tabwidget=new OTabWidget(this);
   setCentralWidget(tabwidget);
   connect(tabwidget,SIGNAL(currentChanged( QWidget *)),this,SLOT(slotCurrentChanged(QWidget *)));
 
 //FILE ACTIONS
         QPopupMenu *popup = new QPopupMenu( this );
 
   // Action for creating a new document
         QAction *a = new QAction( tr( "New" ),  Resource::loadPixmap( "new" ), QString::null, 0, this, 0 );
         a->addTo( popup );
         connect(a, SIGNAL(activated()), this, SLOT(slotNew()));
 
   // Action for opening an exisiting document
         a = new QAction( tr( "Open" ),Resource::loadPixmap( "fileopen" ) , QString::null, 0, this, 0 );
   a->addTo(popup);
         connect(a, SIGNAL(activated()), this, SLOT(slotOpen()));
 
 
   // Action for saving  document
         a = new QAction( tr( "Save" ), Resource::loadPixmap( "save" ) , QString::null, 0, this, 0 );
   a->addTo(popup);
         connect(a, SIGNAL(activated()), this, SLOT(slotSave()));
 
   // Action for saving document to a new name
         a = new QAction( tr( "Save As" ),Resource::loadPixmap( "save" ) , QString::null, 0, this, 0 );
   a->addTo(popup);
         connect(a, SIGNAL(activated()), this, SLOT(slotSaveAs()));
 
   // Action for closing the currently active document
         a = new QAction( tr( "Close" ), Resource::loadPixmap( "quit_icon" ) , QString::null, 0, this, 0 );
   a->addTo(popup);
         connect(a, SIGNAL(activated()), this, SLOT(slotClose()));
 
 
   mb->insertItem(tr("File"),popup);
 
 //EDIT ACTIONS
 
   // Action for cutting text
         editCut = new QToolButton( 0 );
         editCut->setAutoRaise( true );
         editCut->setIconSet(  Resource::loadPixmap( "cut" ) );
 
   // Action for Copying text
         editCopy = new QToolButton( 0 );
         editCopy->setAutoRaise( true );
         editCopy->setIconSet( Resource::loadPixmap( "copy" ) );
 
   // Action for pasting text
         editPaste =  new QToolButton( 0 );
         editPaste->setAutoRaise( true );
         editPaste->setIconSet( Resource::loadPixmap( "paste" ) );
 
   // Action for finding / replacing  text
         editFindReplace = new QToolButton( 0 );
         editFindReplace->setAutoRaise( true );
         editFindReplace->setIconSet( Resource::loadPixmap("find") );
 
    // Action for undo
         editUndo = new QToolButton( 0 );
         editUndo->setAutoRaise( true );
         editUndo->setIconSet( Resource::loadPixmap( "undo" ) );
 
   // Action for redo
         editRedo = new QToolButton( 0 );
         editRedo->setAutoRaise( true );
         editRedo->setIconSet( Resource::loadPixmap( "redo" ) );
 
 //VIEW ACITONS
         popup = new QPopupMenu( this );
 
         viewIncFontSizes = new QAction( tr( "Font +" ), QString::null, 0, this, 0 );
         viewIncFontSizes->addTo( popup );
 
         viewDecFontSizes = new QAction( tr( "Font -" ), QString::null, 0, this, 0 );
         viewDecFontSizes->addTo( popup );
 
         mb->insertItem(tr("View"),popup);
 
         popup = new QPopupMenu( this );
         mb->insertItem(tr("Utils"),popup);
 
 
         mb->insertItem( editCut );
         mb->insertItem( editCopy );
         mb->insertItem( editPaste );
         mb->insertItem( editFindReplace );
         mb->insertItem( editUndo );
         mb->insertItem(  editRedo );
 
 
 //Highlight management
   hlmenu=new QPopupMenu(this);
   HlManager *hlm=HlManager::self();
   for (int i=0;i<hlm->highlights();i++)
   {
     hlmenu->insertItem(hlm->hlName(i),i);
   }
   popup->insertItem(tr("Highlighting"),hlmenu);
 
 
         utilSettings = new QAction( tr( "Settings" ), QString::null, 0, this, 0 );
         utilSettings->addTo( popup);
 
   if( qApp->argc() > 1) open(qApp->argv()[1]);
   else slotNew();
 
 }
 
 TinyKate::~TinyKate( )
 {
   qWarning("TinyKate destructor\n");
 
   shutDown=true;
   while (currentView!=0) {
     slotClose();
   }
 
   if( KGlobal::config() != 0 ) {
     qWarning("deleting KateConfig object..\n");
     delete KGlobal::config();
   }
 }
 
 void TinyKate::slotOpen( )
 {
     QString filename = Opie::OFileDialog::getOpenFileName( OFileSelector::EXTENDED_ALL,
                                                 QString::null);
   if (!filename.isEmpty()) {
     open(filename);
   }
 }
 
 void TinyKate::open(const QString & filename)
 {
     KateDocument *kd= new KateDocument(false, false, this,0,this);
     KTextEditor::View *kv;
     QFileInfo fi(filename);
     QString filenamed = fi.fileName();
     tabwidget->addTab(kv=kd->createView(tabwidget,"bLAH"),"tinykate/tinykate", filenamed );
     qDebug(filename);
 
     kd->setDocName( filenamed);
     kd->open( filename );
     viewCount++;
 }
 
 void TinyKate::setDocument(const QString& fileref)
 {
     open( fileref );
 }
 
 void TinyKate::slotCurrentChanged( QWidget * view)
 {
   if (currentView) {
 
     disconnect(editCopy,SIGNAL(activated()),currentView,SLOT(copy()));
     disconnect(editCut,SIGNAL(activated()),currentView,SLOT(cut()));
     disconnect(editPaste,SIGNAL(activated()),currentView,SLOT(paste()));
     disconnect(editUndo,SIGNAL(activated()),currentView,SLOT(undo()));
     disconnect(editRedo,SIGNAL(activated()),currentView,SLOT(redo()));
     disconnect(viewIncFontSizes,SIGNAL(activated()), currentView,SLOT(slotIncFontSizes()));
     disconnect(viewDecFontSizes,SIGNAL(activated()), currentView,SLOT(slotDecFontSizes()));
     disconnect(hlmenu,SIGNAL(activated(int)), currentView,SLOT(setHl(int)));
     disconnect(utilSettings,SIGNAL(activated()), currentView,SLOT(configDialog()));
   }
 
   currentView=(KTextEditor::View*)view;
 
   connect(editCopy,SIGNAL(clicked()),currentView,SLOT(copy()));
   connect(editCut,SIGNAL(clicked()),currentView,SLOT(cut()));
   connect(editPaste,SIGNAL(clicked()),currentView,SLOT(paste()));
   connect(editUndo,SIGNAL(clicked()),currentView,SLOT(undo()));
   connect(editRedo,SIGNAL(clicked()),currentView,SLOT(redo()));
   connect(viewIncFontSizes,SIGNAL(activated()), currentView,SLOT(slotIncFontSizes()));
   connect(viewDecFontSizes,SIGNAL(activated()), currentView,SLOT(slotDecFontSizes()));
   connect(hlmenu,SIGNAL(activated(int)), currentView,SLOT(setHl(int)));
   connect(utilSettings,SIGNAL(activated()), currentView,SLOT(configDialog()));
 
 }
 
 void TinyKate::slotNew( )
 {
   KateDocument *kd= new KateDocument(false, false, this,0,this);
   KTextEditor::View *kv;
   tabwidget->addTab(kv=kd->createView(tabwidget,"BLAH"),
                     "tinykate/tinykate",
                     tr("Unnamed %1").arg(nextUnnamed++));
   viewCount++;
 }
 
 void TinyKate::slotClose( )
 {
   if (currentView==0) return;
   KTextEditor::View *dv=currentView;
   currentView=0;
   tabwidget->removePage(dv);
   delete dv->document();
   viewCount--;
   if ((!viewCount) && (!shutDown))  slotNew();
 }
 
 void TinyKate::slotSave() {
   // feel free to make this how you want
   if (currentView==0) return;
 
   //  KateView *kv = (KateView*) currentView;
   KateDocument *kd = (KateDocument*) currentView->document();
   //  qDebug("saving file "+kd->docName());
   if( kd->docName().isEmpty())
     slotSaveAs();
   else
      kd->saveFile();
   //    kv->save();
   //    kd->saveFile();
 }
 
 void TinyKate::slotSaveAs() {
   if (currentView==0) return;
   KateDocument *kd = (KateDocument*) currentView->document();
 
   QString filename= Opie::OFileDialog::getSaveFileName(OFileSelector::EXTENDED_ALL,
                                                 QString::null);
   if (!filename.isEmpty()) {
     qDebug("saving file "+filename);
     QFileInfo fi(filename);
     QString filenamed = fi.fileName();
     kd->setDocFile( filename);
     kd->setDocName( filenamed);
     kd->saveFile();
 //   KTextEditor::View *dv = currentView;
 //     tabwidget->changeTab( dv, filenamed);
     // need to change tab label here
   }
 
 }
diff --git a/noncore/apps/zsafe/category.cpp b/noncore/apps/zsafe/category.cpp
index ce1d614..15448f0 100644
--- a/noncore/apps/zsafe/category.cpp
+++ b/noncore/apps/zsafe/category.cpp
@@ -1,63 +1,62 @@
 /* C implementation of RC2 encryption algorithm, as described in RFC2268 */
 /* By Matthew Palmer <mjp16@uow.edu.au> */
 /* $Id$ */
 
 #include "category.h"
-#include <qlistview.h>
 
 Category::Category()
 {
 }
 
 Category::~Category()
 {
 }
 
 QString Category::getIconName()
 {
    return iconName;
 }
 
 QString Category::getCategoryName()
 {
    return categoryName;
 }
 
 QListViewItem * Category::getListItem()
 {
    return listItem;
 }
 
 QPixmap Category::getIcon()
 {
    return icon;
 }
 
 void Category::setIconName(QString name)
 {
    iconName = name;
 }
 
 void Category::setCategoryName(QString name)
 {
    categoryName = name;
 }
 
 void Category::setListItem(QListViewItem *item)
 {
    listItem = item;
 }
 
 void Category::setIcon(QPixmap item)
 {
    icon = item;
 }
 
 void Category::initListItem()
 {
    if (listItem)
    {
       listItem->setText (0, categoryName);
       listItem->setPixmap (0, icon);
    }
 }
diff --git a/noncore/apps/zsafe/main.cpp b/noncore/apps/zsafe/main.cpp
index 7ff549b..4fe319b 100644
--- a/noncore/apps/zsafe/main.cpp
+++ b/noncore/apps/zsafe/main.cpp
@@ -1,112 +1,111 @@
 /*
 ** Author: Carsten Schneider <CarstenSchneider@t-online.de>
 **
 ** $Id$
 **
 ** Homepage: http://home.t-online.de/home/CarstenSchneider/zsafe/index.html
 */
 
 
 #include "zsafe.h"
 #ifdef DESKTOP
 #include <qapplication.h>
 #else
 #include <qpe/qpeapplication.h>
 #endif
 #include <stdio.h>
 #include <signal.h>
-#include "qsettings.h"
 
 ZSafe *zs;
 #ifdef DESKTOP
 QApplication   *appl;
 #else
 QPEApplication *appl;
 #endif
 
 int DeskW;
 int DeskH;
 
 void suspend (int signum)
 {
    printf ("Suspend signal %d received\n", signum);
 }
 
 void resume (int signum)
 {
    printf ("Resume signal %d received\n", signum);
    zs->resume(signum);
 }
 
 int main( int argc, char ** argv )
 {
 #ifndef WIN32
     // install signal handler
     signal (SIGSTOP, suspend);
 #endif
 
 #ifdef DESKTOP
     QApplication a( argc, argv );
 #else
     QPEApplication a( argc, argv );
 #endif
     appl = &a;
 
 #ifdef DESKTOP
     if (argc >= 3)
     {
 #ifndef WIN32
        DeskW = atoi(argv[1]);
        DeskH = atoi(argv[2]);
 #else
 	   int w, h;
 	   sscanf (argv[1], "%d", &w);
 	   sscanf (argv[2], "%d", &h);
 	   DeskW = w;
        DeskH = h;
 #endif
     }
     else
     {
        DeskW = 600;
        DeskH = 400;
     }
 #else
     DeskW = a.desktop()->width();
     DeskH = a.desktop()->height();
 
     char buf[128];
     sprintf (buf, "Width: %d Height: %d\n", DeskW, DeskH);
     qWarning (buf);
 
 #ifdef JPATCH_HDE
     // nothings
 #else
     if (DeskW > 240) 
     {
        DeskW -= 20;
        DeskH += 25;
        sprintf (buf, "Changed width: %d Height: %d\n", DeskW, DeskH);
        qWarning (buf);
     }
 #endif
 
 #endif
 
     ZSafe mw;
     zs = &mw;
 
 #ifndef WIN32
     signal (SIGCONT, resume);
 #endif
 #ifdef DESKTOP
     a.setMainWidget(&mw);
     mw.show();
 #else
     // a.showMainWidget( &mw );
     a.showMainDocumentWidget( &mw );
 #endif
     int ret = a.exec();
 
     return ret;
 }
diff --git a/noncore/apps/zsafe/qsettings.cpp b/noncore/apps/zsafe/qsettings.cpp
index 62a9947..ee55339 100755
--- a/noncore/apps/zsafe/qsettings.cpp
+++ b/noncore/apps/zsafe/qsettings.cpp
@@ -1,153 +1,152 @@
 /*

 ** $Id$

 */

 

 #include "qsettings.h"

-#include <qstringlist.h>

 #include <stdio.h>

 #include <qfile.h>

 #include <qtextstream.h>

 

 

 QSettings::QSettings(const QString &_fn)

 {

 	// read the prefs from the file

 	fn = _fn;

 	

 	QFile f(_fn);

     if ( f.open(IO_ReadOnly) ) {    // file opened successfully

         QTextStream t( &f );        // use a text stream

         QString s;

         while ( !t.eof() ) {        // until end of file...

             s = t.readLine();       // line of text excluding '\n'

 			char buf[256];

 			sprintf (buf, "%s", (const char *) s);

 			int pos = s.find (" = ");

 			QString key = s.left (pos);

 			QString val = s.right (s.length() - pos - 3);

 			writeEntry (key, val);

 			

 			sprintf (buf, "%s|%s", (const char *)key, (const char *)val);

         }

         f.close();

     }

 	

 

 }

 

 QSettings::~QSettings()

 {

 	// write out the prefs to the file

 	QAsciiDictIterator <QString> it( prefs ); // iterator for dict

 	QFile f(fn);

 	f.open(IO_WriteOnly);

 	QTextStream ts( &f );

 

     while ( it.current() )

 	{

 	   QString *key = new QString(it.currentKey());

 	   char buf[256];

 	   sprintf	 (buf, "%s", (const char *) *( it.current()));

 	   QString *val = new QString(buf);

 	   sprintf (buf, "%s %s", (const char *)*key, (const char *)*val);

 	   ts << *key << " = " << *val << endl;

        ++it;

 	}

 	

 	f.close();

 	prefs.clear();

 }

 

 void QSettings::insertSearchPath (System sys, const QString &str)

 {

 	fn = str;

 }

 

 QString QSettings::readEntry (const QString &key, const QString &def)

 {

 	

 	QString *s = prefs.find((const char *)key);

 	if (!s)

 		return def;

 	else 

 		return *s;

 	

 }

 

 int     QSettings::readNumEntry (const QString &key, int def)

 {

 	QString *s = prefs[key];

 	if (!s) return def;

     return s->toInt();

 }

 

 bool    QSettings::readBoolEntry (const QString &key, bool def)

 {

 	QString *s = prefs[key];

 	if (!s) return def;

 	if (*s == "1")

 		return true;

 	else

 		return false;

 }

 

 bool    QSettings::writeEntry (const QString &key, int val)

 {

 	char buf[64];

 	sprintf (buf, "%d", val);

 	QString *v = new QString(buf);

     prefs.replace ((const char *)key, v);

 	return true;

 }

 

 bool    QSettings::writeEntry (const QString &key, bool val)

 {

 	QString *v;

 	if (val)

 	   v = new QString("1");

 	else

        v = new QString("0");

     prefs.replace ((const char *)key, v);

 	return true;

 }

 

 bool    QSettings::writeEntry (const QString &key, const QString &val)

 {

 	QString *v = new QString (val);

 	prefs.replace ((const char *)key, v);

 	return true;

 }

 

 bool    QSettings::writeEntry (const QString &key, const char *val)

 {

 	QString *v = new QString (val);

 	prefs.replace ((const char *)key, v);

 	return true;

 }

 

 bool    QSettings::removeEntry (const QString &key)

 {

 	prefs.remove (key);

 	return true;

 }

 

 QStringList QSettings::entryList (const QString &key) const

 {

 	QAsciiDictIterator <QString> it( prefs ); // iterator for dict

 	QStringList list;

 

     while ( it.current() )

 	{

 	   char buf[512];

 	   sprintf	 (buf, "%s", (const char *) *( it.current()));

 	   QString *val = new QString(buf);

        sprintf(buf, "%s -> %s\n", it.currentKey(), (const char *)*val );

 	   QString *cat = new QString(it.currentKey());

        if (cat->contains("-field", FALSE))

 	      list.append (it.currentKey());

        ++it;

     

 	}

 	return list;

 }

 

diff --git a/noncore/apps/zsafe/scqtfiledlg.cpp b/noncore/apps/zsafe/scqtfiledlg.cpp
index d6cea64..dd72fdf 100644
--- a/noncore/apps/zsafe/scqtfiledlg.cpp
+++ b/noncore/apps/zsafe/scqtfiledlg.cpp
@@ -1,261 +1,256 @@
 /****************************************************************************
 ** Form implementation generated from reading ui file 'scqtfiledlg.ui'
 **
 ** Created: Sun Jun 8 15:51:12 2003
 **      by:  The User Interface Compiler (uic)
 **
 ** WARNING! All changes made in this file will be lost!
 ****************************************************************************/
 #include "scqtfiledlg.h"
 
 #include <qcombobox.h>
-#include <qheader.h>
 #include <qlineedit.h>
 #include <qlistview.h>
-#include <qpushbutton.h>
 #include <qtoolbutton.h>
 #include <qlayout.h>
-#include <qvariant.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
-#include <qimage.h>
-#include <qpixmap.h>
 
 static const char* const image0_data[] = { 
 "24 16 3 1",
 ". c None",
 "# c #000040",
 "a c #808080",
 "........................",
 "........................",
 ".................####...",
 ".................####...",
 ".......##........#aa#...",
 "......###........#aa#...",
 ".....####........#aa#...",
 "....##############aa#...",
 "...###aaaaaaaaaaaaaa#...",
 "..####aaaaaaaaaaaaaa#...",
 "...###aaaaaaaaaaaaaa#...",
 "....#################...",
 ".....####...............",
 "......###...............",
 ".......##...............",
 "........................"};
 
 static const char* const image1_data[] = { 
 "24 16 4 1",
 ". c None",
 "a c #008080",
 "b c #808080",
 "# c #ff0000",
 "........................",
 "........................",
 "...####..........####...",
 "...#####........#####...",
 "....######.....#####a...",
 ".....######...#####ba...",
 ".....aa###########bba...",
 "....aaaaa#######aabba...",
 "...aaabbb######bbbbba...",
 "..aaaabb########bbbba...",
 "...aaa############bba...",
 "....a######aaa#####aa...",
 "....######.....######...",
 "...#####a........####...",
 "...####aa.........###...",
 "........................"};
 
 static const char* const image2_data[] = { 
 "17 15 4 1",
 "# c #000000",
 ". c #dcdcdc",
 "a c #ffff00",
 "b c #ffffff",
 ".................",
 "............#....",
 ".................",
 "............#....",
 ".........#.....#.",
 "....####..#.#.#..",
 "...#abab#..#.#...",
 "..##########..#.#",
 "..#babababab##...",
 "..#ababababa#.#..",
 "..#babababab#..#.",
 "..#ababababa#....",
 "..#babababab#....",
 "..#ababababa#....",
 "..###########...."};
 
 
 /* 
  *  Constructs a ScQtFileDlg which is a child of 'parent', with the 
  *  name 'name' and widget flags set to 'f' 
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 ScQtFileDlg::ScQtFileDlg( QWidget* parent,  const char* name, bool modal, WFlags fl )
     : QDialog( parent, name, modal, fl )
 {
     QPixmap image0( ( const char** ) image0_data );
     QPixmap image1( ( const char** ) image1_data );
     QPixmap image2( ( const char** ) image2_data );
     if ( !name )
 	setName( "ScQtFileDlg" );
     resize( 196, 279 ); 
     if (!name)
        setCaption( tr( "FileDlg" ) );
     else
        setCaption(name);
     ScQtFileDlgLayout = new QVBoxLayout( this ); 
     ScQtFileDlgLayout->setSpacing( 6 );
     ScQtFileDlgLayout->setMargin( 11 );
 
     Layout5 = new QVBoxLayout; 
     Layout5->setSpacing( 6 );
     Layout5->setMargin( 0 );
 
     Layout4 = new QVBoxLayout; 
     Layout4->setSpacing( 6 );
     Layout4->setMargin( 0 );
 
     Layout3 = new QHBoxLayout; 
     Layout3->setSpacing( 6 );
     Layout3->setMargin( 0 );
 
     TypeComboBox = new QComboBox( FALSE, this, "TypeComboBox" );
     TypeComboBox->setEditable( TRUE );
     TypeComboBox->setInsertionPolicy( QComboBox::AtBottom );
     TypeComboBox->setAutoCompletion( FALSE );
     TypeComboBox->setDuplicatesEnabled( FALSE );
     QToolTip::add(  TypeComboBox, tr( "file type filter" ) );
     QWhatsThis::add(  TypeComboBox, tr( "ComboBox FileTypeFilter\n"
 "\n"
 "edit or select the filter" ) );
     Layout3->addWidget( TypeComboBox );
     QSpacerItem* spacer = new QSpacerItem( 20, 20, QSizePolicy::Expanding, QSizePolicy::Minimum );
     Layout3->addItem( spacer );
 
     OkButton = new QToolButton( this, "OkButton" );
     OkButton->setText( tr( "" ) );
     OkButton->setPixmap( image0 );
     OkButton->setUsesBigPixmap( FALSE );
     QToolTip::add(  OkButton, tr( "confirms the selection and closes the form" ) );
     QWhatsThis::add(  OkButton, tr( "OKButton" ) );
     Layout3->addWidget( OkButton );
 
     CancelButton = new QToolButton( this, "CancelButton" );
     CancelButton->setText( tr( "" ) );
     CancelButton->setPixmap( image1 );
     CancelButton->setUsesBigPixmap( FALSE );
     QToolTip::add(  CancelButton, tr( "cancels the selection and closes the form" ) );
     QWhatsThis::add(  CancelButton, tr( "CancelButton" ) );
     Layout3->addWidget( CancelButton );
     Layout4->addLayout( Layout3 );
 
     Layout3_2 = new QHBoxLayout; 
     Layout3_2->setSpacing( 6 );
     Layout3_2->setMargin( 0 );
 
     FNameLineEdit = new QLineEdit( this, "FNameLineEdit" );
     QToolTip::add(  FNameLineEdit, tr( "shows the selected filename" ) );
     QWhatsThis::add(  FNameLineEdit, tr( "Filename LineEdit\n"
 "\n"
 "shows the selected file\n"
 "and allows the direct filename\n"
 "edit" ) );
     Layout3_2->addWidget( FNameLineEdit );
 
     MkDirButton = new QToolButton( this, "MkDirButton" );
     MkDirButton->setText( tr( "" ) );
     MkDirButton->setPixmap( image2 );
     MkDirButton->setUsesBigPixmap( FALSE );
     QToolTip::add(  MkDirButton, tr( "confirms the selection and closes the form" ) );
     QWhatsThis::add(  MkDirButton, tr( "OKButton" ) );
     Layout3_2->addWidget( MkDirButton );
     Layout4->addLayout( Layout3_2 );
 
     DirComboBox = new QComboBox( FALSE, this, "DirComboBox" );
     DirComboBox->setSizePolicy( QSizePolicy( (QSizePolicy::SizeType)7, (QSizePolicy::SizeType)0, DirComboBox->sizePolicy().hasHeightForWidth() ) );
     DirComboBox->setEditable( TRUE );
     DirComboBox->setDuplicatesEnabled( FALSE );
     QWhatsThis::add(  DirComboBox, tr( "ComboBox Directory \n"
 "edit or select the directories name" ) );
     Layout4->addWidget( DirComboBox );
     Layout5->addLayout( Layout4 );
 
     ListView = new QListView( this, "ListView" );
     ListView->addColumn( tr( "Name" ) );
     ListView->addColumn( tr( "size" ) );
     ListView->addColumn( tr( "type" ) );
     ListView->setRootIsDecorated( TRUE );
     QToolTip::add(  ListView, tr( "directory listview" ) );
     QWhatsThis::add(  ListView, tr( "Directory ListView\n"
 "\n"
 "shows the list of dirs and files" ) );
     Layout5->addWidget( ListView );
     ScQtFileDlgLayout->addLayout( Layout5 );
 
     // signals and slots connections
     connect( OkButton, SIGNAL( clicked() ), this, SLOT( slotOK() ) );
     connect( DirComboBox, SIGNAL( activated(int) ), this, SLOT( slotDirComboBoxChanged( int ) ) );
     connect( TypeComboBox, SIGNAL( activated(int) ), this, SLOT( slotTypeComboBoxChanged( int ) ) );
     connect( CancelButton, SIGNAL( clicked() ), this, SLOT( slotCancel() ) );
     connect( ListView, SIGNAL( returnPressed(QListViewItem*) ), this, SLOT( slotSelectionChanged(QListViewItem *) ) );
     connect( ListView, SIGNAL( selectionChanged(QListViewItem*) ), this, SLOT( slotSelectionChanged(QListViewItem *) ) );
     connect( ListView, SIGNAL( doubleClicked(QListViewItem*) ), this, SLOT( slotDoubleClicked(QListViewItem *) ) );
     connect( FNameLineEdit, SIGNAL( textChanged(const QString&) ), this, SLOT( slotFileTextChanged( const QString & ) ) );
     connect( FNameLineEdit, SIGNAL( returnPressed() ), this, SLOT( slotOK() ) );
     connect( MkDirButton, SIGNAL( clicked() ), this, SLOT( slotMkDir() ) );
 }
 
 /*  
  *  Destroys the object and frees any allocated resources
  */
 ScQtFileDlg::~ScQtFileDlg()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 void ScQtFileDlg::slotCancel()
 {
     qWarning( "ScQtFileDlg::slotCancel(): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotDirComboBoxChanged( int )
 {
     qWarning( "ScQtFileDlg::slotDirComboBoxChanged( int ): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotDoubleClicked(QListViewItem *)
 {
     qWarning( "ScQtFileDlg::slotDoubleClicked(QListViewItem *): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotFileTextChanged( const QString & )
 {
     qWarning( "ScQtFileDlg::slotFileTextChanged( const QString & ): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotMkDir()
 {
     qWarning( "ScQtFileDlg::slotMkDir(): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotOK()
 {
     qWarning( "ScQtFileDlg::slotOK(): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotSelectionChanged(QListViewItem *)
 {
     qWarning( "ScQtFileDlg::slotSelectionChanged(QListViewItem *): Not implemented yet!" );
 }
 
 void ScQtFileDlg::slotTypeComboBoxChanged( int )
 {
     qWarning( "ScQtFileDlg::slotTypeComboBoxChanged( int ): Not implemented yet!" );
 }
 
diff --git a/noncore/apps/zsafe/scqtfileedit.cpp b/noncore/apps/zsafe/scqtfileedit.cpp
index 7a3d906..08fc2b5 100644
--- a/noncore/apps/zsafe/scqtfileedit.cpp
+++ b/noncore/apps/zsafe/scqtfileedit.cpp
@@ -1,409 +1,405 @@
 /***************************************************************************
                           scqtfileedit.cpp  -  description
                              -------------------
     begin                : Mon Sep 3 2001
     copyright            : (C) 2001 by Werner Schulte
     email                : sc@schulte-ac.de
  ***************************************************************************/
 
 /* $Id$ */
 
 /***************************************************************************
  *                                                                         *
  *   This program is free software; you can redistribute it and/or modify  *
  *   it under the terms of the GNU General Public License as published by  *
  *   the Free Software Foundation; either version 2 of the License, or     *
  *   (at your option) any later version.                                   *
  *                                                                         *
  ***************************************************************************/
 #include <stdio.h>
 #include <stdlib.h>
 
-#include "qdir.h"
-#include "qdialog.h"
-#include "qpixmap.h"
-#include "qlistview.h"
 #include "qlineedit.h"
 #include "qtoolbutton.h"
 
 #include "scqtfileedit.h"
 
 #include <qpe/qpeapplication.h>
 
 // #define DEBUGFILEEDIT
 
 /* XPM */
 static const char* const file_xpm[]={
     "16 16 5 1",
     ". c #7f7f7f",
     "# c None",
     "c c #000000",
     "b c #bfbfbf",
     "a c #ffffff",
     "################",
     "..........######",
     ".aaaaaaaab.#####",
     ".aaaaaaaaba.####",
     ".aaaaaaaacccc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".bbbbbbbbbbbc###",
     "ccccccccccccc###"};
 
 /* XPM */
 static const char * const link_file_xpm[]={
     "16 16 10 1",
     "h c #808080",
     "g c #a0a0a0",
     "d c #c3c3c3",
     ". c #7f7f7f",
     "c c #000000",
     "b c #bfbfbf",
     "f c #303030",
     "e c #585858",
     "a c #ffffff",
     "# c None",
     "################",
     "..........######",
     ".aaaaaaaab.#####",
     ".aaaaaaaaba.####",
     ".aaaaaaaacccc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaabc###",
     ".aaaaaaaaaadc###",
     ".aaaaaaaaaadc###",
     ".aaaacccccccc###",
     ".aaaacaaaaaac###",
     ".aaaacaeaeaac###",
     ".aaaacaefcfac###",
     ".aaaacaagchac###",
     ".ddddcaaahaac###",
     "ccccccccccccc###"};
 
 /* XPM */
 static const char * const closed_xpm[]={
     "16 16 6 1",
     ". c None",
     "b c #ffff00",
     "d c #000000",
     "* c #999999",
     "a c #cccccc",
     "c c #ffffff",
     "................",
     "................",
     "..*****.........",
     ".*ababa*........",
     "*abababa******..",
     "*cccccccccccc*d.",
     "*cbababababab*d.",
     "*cabababababa*d.",
     "*cbababababab*d.",
     "*cabababababa*d.",
     "*cbababababab*d.",
     "*cabababababa*d.",
     "*cbababababab*d.",
     "**************d.",
     ".dddddddddddddd.",
     "................"};
 
 /* XPM */
 static const char* const cdtoparent_xpm[]={
     "15 13 3 1",
     ". c None",
     "* c #000000",
     "a c #ffff99",
     "..*****........",
     ".*aaaaa*.......",
     "***************",
     "*aaaaaaaaaaaaa*",
     "*aaaa*aaaaaaaa*",
     "*aaa***aaaaaaa*",
     "*aa*****aaaaaa*",
     "*aaaa*aaaaaaaa*",
     "*aaaa*aaaaaaaa*",
     "*aaaa******aaa*",
     "*aaaaaaaaaaaaa*",
     "*aaaaaaaaaaaaa*",
     "***************"};
 
 ScQtFileEditDlg::ScQtFileEditDlg( QWidget *parent, const char *name,
                           const QString &path, const QString &filter )
           : ScQtFileDlg( parent, name, TRUE ), QDir( path, filter )
 {
 //  ListView->setRootIsDecorated ( TRUE );
 
 #ifdef DEBUGFILEEDIT
   printf ("\nScQtFileEditDlg:: constructor name=%s", name );
   printf ("\n   path=%s", (const char *)path );
   printf ("\n   filter=%s", (const char *)filter );
   printf ("\n   parent=%p", parent );
   fflush(stdout);
 #endif
 
   bpath    = path;
   bfilter  = filter;
   exflag   = false;
 
   ListView->setAllColumnsShowFocus( TRUE );
   ListView->setColumnAlignment( 1, Qt::AlignRight );
 
   fileIcon = new QPixmap( (const char **)file_xpm);
   dirIcon = new QPixmap( (const char **)closed_xpm);
   linkIcon = new QPixmap( (const char **)link_file_xpm);
   cdToParentIcon = new QPixmap( (const char **)cdtoparent_xpm);
 
 #ifdef QWS
   QPEApplication::execDialog( this );
 #endif
 
   mkdirflag = false;
   MkDirButton->setEnabled( false );
 
   initDirCombo( bpath );
   initTypeCombo( bfilter );
 
   dirstr  = tr("dir");
   filestr = tr("file");
   linkstr = tr("link");
 
   rFlag = false;
 
   showTimer.stop();
   connect( &showTimer, SIGNAL(timeout()), SLOT( slotShowDir() ) );
 
   fmode = QDir::All;
   fnfilter = false;
   fsorting = false;
 
 }
 
 ScQtFileEditDlg::~ScQtFileEditDlg()
 {
 #ifdef DEBUGFILEEDIT
   printf ("\nScQtFileEditDlg::destructor called" );
   fflush(stdout);
 #endif
 
   if ( fileIcon != NULL )
   {
     delete fileIcon;
     fileIcon = NULL;
   }
   if ( dirIcon != NULL )
   {
     delete dirIcon;
     dirIcon = NULL;
   }
   if ( linkIcon != NULL )
   {
     delete linkIcon;
     linkIcon = NULL;
   }
   if ( cdToParentIcon != NULL )
   {
     delete cdToParentIcon;
     cdToParentIcon = NULL;
   }
 }
 
 void ScQtFileEditDlg::readIt( )
 {
   qfil = readDir( bpath, bfilter );
   slotShowDir( );
 }
 
 void ScQtFileEditDlg::setAutoExtension( bool ex )
 {
   exflag = ex;
 }
 
 
 int ScQtFileEditDlg::checkComboEntryExists( QComboBox *com, const QString &str )
 {
   int i;
 
   if ( com )
   {
     for ( i = 0; i < com->count(); i++ )
     {
       if ( com->text( i ) == str )
       {
         com->setCurrentItem( i );
         return( 1 );
       }
     }
   }
 
   return( 0 );
 }
 
 
 void ScQtFileEditDlg::initDirCombo( const QString &str )
 {
   DirComboBox->clear();
   DirComboBox->insertItem( "/" );
   if ( str.isEmpty() )
     return;
   DirComboBox->insertItem( str, -1 );
 }
 
 void ScQtFileEditDlg::initTypeCombo( const QString &str )
 {
   TypeComboBox->clear();
   TypeComboBox->insertItem( "*" );
   if ( str.isEmpty() )
     return;
   TypeComboBox->insertItem( str, -1 );
 }
 
 void ScQtFileEditDlg::insDirCombo( const QString &str )
 {
   if ( str.isEmpty() )
     return;
 
   if ( !checkComboEntryExists( DirComboBox, str ) )
   {
     if ( DirComboBox->count() >= MAXDIRCOMBOCOUNT )
     {
       // 2. Item loeschen (das erste ist "/")
       DirComboBox->removeItem( 1 );
     }
     // neues Item anhaengen
     DirComboBox->insertItem( str, -1 );
     DirComboBox->setCurrentItem( DirComboBox->count() - 1 );
   }
 }
 
 void ScQtFileEditDlg::insTypeCombo( const QString &str )
 {
   if ( str.isEmpty() )
     return;
 
   if ( !checkComboEntryExists( TypeComboBox, str ) )
   {
     if ( TypeComboBox->count() >= MAXTYPECOMBOCOUNT )
     {
       // 2. Item loeschen (das erste ist "/")
       TypeComboBox->removeItem( 1 );
     }
     // neues Item anhaengen
     TypeComboBox->insertItem( str, -1 );
     TypeComboBox->setCurrentItem( TypeComboBox->count() - 1 );
   }
 }
 
 
 const QFileInfoList *ScQtFileEditDlg::readDir( const QString &path, const QString &filter )
 {
     static QString qpath, qfilter;
 
 #ifdef DEBUGFILEEDIT
   printf ("\nScQtFileEditDlg::readDir called, path = %s", (const char *)path );
   printf ("\n                             filter = %s", (const char *)filter );
   fflush(stdout);
 #endif
 
     rFlag = true;
 
     if ( path.isEmpty() )
       qpath = "/";
     else
       qpath = path;
 
     if ( filter.isEmpty() )
       qfilter = "*";
     else
       qfilter = filter;
 
     insDirCombo( qpath );
     insTypeCombo( qfilter );
 
     setFilter( fmode );
     if ( fsorting )
       setSorting(  QDir::DirsFirst | QDir::Name );
     if ( fnfilter )
       setNameFilter( qfilter );
     setPath( qpath );
 
     const QFileInfoList *dirlist = entryInfoList();
 
     if ( !dirlist )
     {
       rFlag = false;
       return( 0 );
     }
 
     rFlag = false;
 
     return( dirlist );
 }
 
 QString ScQtFileEditDlg::getResult( )
 {
   static QString qstr;
 
 #ifdef DEBUGFILEEDIT
   printf ("\nScQtFileEditDlg::getResult called" );
   fflush(stdout);
 #endif
 
   qstr = bpath + "/";
   qstr = qstr + filename;
   bpath = cleanDirPath( qstr );
 
   return( bpath );
 }
 
 QString ScQtFileEditDlg::getFileName( )
 {
   int a;
   static QString qstr;
 
 #ifdef DEBUGFILEEDIT
   printf ("\nScQtFileEditDlg::getFileName called" );
   fflush(stdout);
 #endif
 
   a = bpath.findRev( "/", -1, TRUE );
   if (a == -1)
     qstr = bpath;  // Nicht gefunden
   else
     qstr = bpath.right( bpath.length() - a - 1 );
 
   return( qstr );
 }
 
 // Ab hier die Slots -----------------------------------
 
 void ScQtFileEditDlg::slotShowDir()
 {
     static QListViewItem *qlvitem;
     static QString ftypestr, fsizestr;
     static QFileInfo *fi;                   // pointer for traversing
 
     if ( !qfil )                            // pointer war Null
       return;
 
     ListView->clear();  // ersma loeschen
     QFileInfoListIterator it( *qfil );             // create list iterator
     if ( !it )                                     // pointer war Null
       return;
 
     while ( (fi=it.current()) )
     {           // for each file...
        if ( !fi )   // current war 0
          return;
 
        if ( !fi->fileName().isNull() )
        {
          if ( fi->isDir() == TRUE )
          {
            ftypestr = dirstr;
            fsizestr = "" ;
diff --git a/noncore/apps/zsafe/zlistview.cpp b/noncore/apps/zsafe/zlistview.cpp
index 23bbc4e..ba02a15 100644
--- a/noncore/apps/zsafe/zlistview.cpp
+++ b/noncore/apps/zsafe/zlistview.cpp
@@ -1,38 +1,36 @@
 /*
 ** $Id$
 */
 
 #include "zlistview.h"
-#include <qlistview.h>
-#include <qevent.h>
 #include <stdio.h>
 #include "zsafe.h"
 
 ZListView::ZListView (ZSafe *zsafe, const char *id) : QListView(zsafe, id)
 {
    zs = zsafe;
 }
 
 ZListView::~ZListView()
 {
 }
 
 void ZListView::keyPressEvent ( QKeyEvent *e )
 {
 /*
    char buf[64];
    sprintf (buf, "key: %d\n", e->key());
    qWarning (buf);
 */
 
    switch (e->key())
    {
       case 32: // middle cursor key pressed
          zs->showInfo (zs->selectedItem);
          break;
       default:
          QListView::keyPressEvent( e );
    }
 
 }
 
diff --git a/noncore/apps/zsafe/zsafe.cpp b/noncore/apps/zsafe/zsafe.cpp
index f43a206..a3e805e 100644
--- a/noncore/apps/zsafe/zsafe.cpp
+++ b/noncore/apps/zsafe/zsafe.cpp
@@ -1,466 +1,465 @@
 /****************************************************************************
 **
 ** Created: Sat Apr 6 17:57:45 2002
 **
 ** Author: Carsten Schneider <CarstenSchneider@t-online.de>
 **
 ** $Id$
 **
 ** Homepage: http://home.t-online.de/home/CarstenSchneider/zsafe/index.html
 **
 ** Compile Flags:
 **    Zaurus arm     : -DNO_OPIE
 **    Zaurus Opie arm: none
 **    Linux Desktop  : -DDESKTOP
 **    Windows Desktop: -DDESKTOP -DWIN32
 **
 **    for japanese version additional use: -DJPATCH_HDE
 **
 ****************************************************************************/
 #include "zsafe.h"
 #include "newdialog.h"
 #include "searchdialog.h"
 #include "categorydialog.h"
 #include "passworddialog.h"
 #include "infoform.h"
 #include "zlistview.h"
 #include "shadedlistitem.h"
 
 #ifndef DESKTOP
 #ifndef NO_OPIE
 #include <opie2/ofiledialog.h>
 
 using Opie::OFileDialog;
 using Opie::OFileSelector;
 #else
 #include "scqtfileedit.h"
 #endif
 #endif
 
 #include <qclipboard.h>
 
 #include <stdio.h>
 
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <stdlib.h>
 #ifndef WIN32
 #include <unistd.h>
 #endif
 #include <string.h>
 #include <errno.h>
 
 #include <qmenubar.h>
 #include <qpopupmenu.h>
 
 #ifdef DESKTOP
 #include <qfiledialog.h>
 #ifndef WIN32
 #include <qsettings.h>
 #else
 #include "qsettings.h"
 #endif
 #include <qapplication.h>
 #else
 #include <qfile.h>
 #include <qpe/fileselector.h>
 #include <qpe/global.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/config.h>
 #endif
 
 #include <qtimer.h>
 #include <qlayout.h>
 #include <qmessagebox.h>
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qheader.h>
 #include <qlistview.h>
 #include <qtoolbutton.h>
-#include <qlayout.h>
 #include <qvariant.h>
 #include <qtooltip.h>
 #include <qwhatsthis.h>
 #include <qimage.h>
 #include <qpixmap.h>
 #include <qlineedit.h>
 #include <qmultilineedit.h>
 #include <qregexp.h>
 #include <qdir.h>
 #include <qtextbrowser.h>
 #include <qlabel.h>
 #include <qcombobox.h>
 
 #include "krc2.h"
 
 #include "wait.h"
 
 extern int DeskW, DeskH;
 #ifdef DESKTOP
 extern QApplication   *appl;
 #else
 extern QPEApplication *appl;
 #endif
 
 #ifdef JPATCH_HDE
 #define tr(arg) arg
 #endif
 
 
 #ifdef DESKTOP
 #ifndef WIN32
 const QString APP_KEY="/.zsafe/";
 #else
 const QString APP_KEY="";
 #endif
 #else
 const QString APP_KEY="";
 #endif
 
 // include xmp images
 #include "pics/zsafe/copy.xpm"
 #include "pics/zsafe/cut.xpm"
 #include "pics/zsafe/edit.xpm"
 #include "pics/zsafe/editdelete.xpm"
 #include "pics/zsafe/find.xpm"
 #include "pics/zsafe/folder_open.xpm"
 #include "pics/zsafe/help_icon.xpm"
 #include "pics/zsafe/new.xpm"
 #include "pics/zsafe/paste.xpm"
 #include "pics/zsafe/quit_icon.xpm"
 #include "pics/zsafe/save.xpm"
 #include "pics/zsafe/trash.xpm"
 #include "pics/zsafe/expand.xpm"
 #include "pics/zsafe/export.xpm"
 #include "pics/zsafe/import.xpm"
 #include "pics/zsafe/zsafe.xpm"
 
 static const char* const bank_cards_data[] = {
 "14 14 16 1",
 ". c None",
 "# c #000000",
 "b c #0000de",
 "a c #0000e6",
 "j c #41de83",
 "k c #4acecd",
 "h c #4aced5",
 "g c #5a40cd",
 "d c #5a44d5",
 "l c #9440d5",
 "m c #b4ce4a",
 "n c #cd4883",
 "e c #d5ae10",
 "f c #de3ce6",
 "i c #e640e6",
 "c c #ffffff",
 "..............",
 ".###########..",
 ".#ababababa#..",
 ".#babbbabbb#..",
 ".#ccccccccc#..",
 ".#cdcefcghc#..",
 ".#ccccccccc#..",
 ".#cicjkclic#..",
 ".#ccccccccc#..",
 ".#cmchlcnec#..",
 ".#ccccccccc#..",
 ".###########..",
 "..............",
 ".............."};
 
 
 static const char* const passwords_data[] = {
 "16 16 20 1",
 ". c None",
 "# c #000000",
 "r c #000083",
 "p c #0000c5",
 "q c #0000ff",
 "n c #008100",
 "l c #00c200",
 "m c #00ff00",
 "j c #838100",
 "a c #c55900",
 "h c #c5c200",
 "o c #c5c2ff",
 "k c #c5ffc5",
 "f c #ff0000",
 "d c #ff8100",
 "b c #ffaa5a",
 "e c #ffc2c5",
 "c c #ffdeac",
 "i c #ffff00",
 "g c #ffffc5",
 "............###.",
 "...........#abb#",
 "..........#cbab#",
 ".........#cbdd#.",
 "######..#cbdd#..",
 "#eeff#..#add#...",
 "#eeff#######....",
 "#ccdbdd#........",
 "#dddbdd###......",
 "#gghihhjj#......",
 "#hhhihhjj###....",
 "#kklmllnnnn#....",
 "#lllmllnnnn#....",
 "#oopqpprprr#....",
 "#oopqpprprr#....",
 "############...."};
 
 static const char* const software_data[] = {
 "16 16 5 1",
 ". c None",
 "# c #000000",
 "b c #838183",
 "c c #c5ffff",
 "a c #ffffff",
 "................",
 ".##############.",
 "#aaaaaaaaaaaaaa#",
 "#abbbbbbbbbbbbb#",
 "#ab##########ab#",
 "#ab#c########ab#",
 "#ab#c#c######ab#",
 "#ab##########ab#",
 "#ab##########ab#",
 "#ab##########ab#",
 "#ab##########ab#",
 "#ab##########ab#",
 "#aaaaaaaaaaaaab#",
 "#bbbbbbbbbbbbbb#",
 ".##############.",
 "................"};
 
 static const char* const general_data[] = {
 "14 14 98 2",
 "Qt c None",
 ".k c #000000",
 "#x c #080808",
 "#F c #101008",
 "#q c #101010",
 "#i c #101410",
 "## c #101810",
 ".m c #181818",
 ".3 c #181c18",
 ".I c #182018",
 ".T c #202420",
 "#D c #202820",
 "#y c #292c29",
 ".c c #293029",
 ".d c #313031",
 "#E c #313429",
 "#r c #313831",
 ".j c #393c31",
 "#j c #394039",
 "#C c #414841",
 ".w c #4a554a",
 ".a c #4a594a",
 ".# c #525052",
 ".l c #52594a",
 "#f c #525952",
 "#v c #525d52",
 ".O c #5a4c4a",
 ".9 c #5a595a",
 ".A c #5a5d52",
 ".B c #624c52",
 ".0 c #625552",
 "#o c #626562",
 ".R c #626962",
 "#. c #626d5a",
 "#p c #626d62",
 ".2 c #627162",
 "#h c #6a6d62",
 "#z c #6a7562",
 "#w c #6a756a",
 ".C c #73656a",
 ".P c #73696a",
 "#a c #737d6a",
 ".U c #738573",
 ".E c #7b817b",
 "#B c #7b857b",
 "#s c #7b897b",
 "#n c #7b917b",
 ".b c #838d83",
 ".7 c #839583",
 ".n c #8b7d7b",
 "#g c #8b8583",
 ".g c #8b858b",
 ".r c #8b898b",
 ".s c #8b8d8b",
 ".i c #8b9183",
 ".8 c #8b918b",
 "#A c #8b9d8b",
 ".S c #8ba183",
 ".Z c #94918b",
 ".N c #949994",
 ".F c #949d94",
 ".x c #94a18b",
 ".v c #94a194",
 ".Y c #94aa94",
 ".h c #9c999c",
 ".Q c #9ca19c",
 "#u c #9ca59c",
 ".H c #9caa9c",
 "#e c #9cb29c",
 "#m c #a4b29c",
 "#t c #a4b2a4",
 ".M c #a4b69c",
 "#l c #a4b6a4",
 ".z c #a4baa4",
 ".f c #aca5ac",
 ".q c #acaaac",
 "#d c #acbeac",
 ".6 c #acc2ac",
 ".o c #b4b2b4",
 ".t c #b4beb4",
 "#k c #b4c2ac",
 ".5 c #b4cab4",
 ".D c #bdb6bd",
 ".G c #bdc6b4",
 "#c c #bdceb4",
 ".X c #bdd2bd",
 ".4 c #bdd6bd",
 ".1 c #c5bec5",
 ".e c #c5c2c5",
 ".u c #c5cac5",
 "#b c #c5d6c5",
 ".J c #c5dec5",
 ".p c #cdcacd",
 ".W c #cddecd",
 ".L c #cde2cd",
 ".K c #d5eacd",
 ".V c #d5ead5",
 ".y c #d5eed5",
 "QtQtQtQtQtQtQtQtQtQtQtQtQtQt",
 "QtQtQt.#.a.b.cQtQtQtQtQtQtQt",
 "QtQt.d.e.f.g.h.i.c.j.dQt.kQt",
 ".a.l.m.n.o.p.q.r.s.t.u.v.wQt",
 ".x.y.z.A.B.C.D.p.q.E.F.G.H.I",
 ".I.J.K.L.M.N.O.P.o.p.Q.R.S.T",
 "Qt.U.V.L.W.X.Y.Z.0.P.1.s.2.3",
 "Qt.3.X.W.4.X.5.6.7.8.9.s#.##",
 "QtQt#a.X#b#c.5.6#d#e#f#g#h#i",
 "QtQtQt#j.7#k.6#d#l#m#n#o#p#q",
 "QtQtQtQt.k#r#s#m#t.H#u#v#w#x",
 "QtQtQtQtQtQt.k#y#z.v#A#B#C#x",
 "QtQtQtQtQtQtQtQt.k#D.w#s#E.k",
 "QtQtQtQtQtQtQtQtQtQtQt#x#FQt"};
 
 // exit ZSafe and clear the clipboard for security reasons
   void ZSafe::exitZs (int ec)
   {
      QClipboard *cb = QApplication::clipboard();
      cb->clear();
 
      exit (ec);
   }
 
 
 // save the configuration into the file
   void ZSafe::saveConf ()
   {
     if (conf)
     {
        delete conf;
 
 #ifdef DESKTOP
 #ifndef WIN32
        conf = new QSettings ();
        conf->insertSearchPath (QSettings::Unix, QDir::homeDirPath());
 #else
        conf = new QSettings (cfgFile);
        conf->insertSearchPath (QSettings::Unix, cfgFile);
 #endif
 #else
        conf = new Config (cfgFile, Config::File);
        conf->setGroup ("zsafe");
 #endif
     }
   }
 
 
 /*
  *  Constructs a ZSafe which is a child of 'parent', with the
  *  name 'name' and widget flags set to 'f'
  *
  *  The dialog will by default be modeless, unless you set 'modal' to
  *  TRUE to construct a modal dialog.
  */
 ZSafe::ZSafe( QWidget* parent,  const char* name, bool modal, WFlags fl )
     : QDialog( parent, name, modal, fl ),
       Edit(0l), Delete(0l), Find(0l), New(0l), ListView(0l)
 {
     IsCut = false;
     IsCopy = false;
     modified = false;
 
     // set the config file
     cfgFile=QDir::homeDirPath();
     cfgFile += "/.zsafe.cfg";
     // set the icon path
 #ifdef NO_OPIE
     QString qpedir ((const char *)getenv("QPEDIR"));
 #else
     QString qpedir ((const char *)getenv("OPIEDIR"));
 #endif
 
 #ifdef DESKTOP
     iconPath = QDir::homeDirPath() + "/pics/";
 #else
     if (qpedir.isEmpty())
        iconPath = "/home/QtPalmtop/pics/";
     else
        iconPath = qpedir + "/pics/";
 #endif
 
     // create a zsafe configuration object
 #ifdef DESKTOP
 #ifndef WIN32
     conf = new QSettings ();
     conf->insertSearchPath (QSettings::Unix, QDir::homeDirPath());
 #else
     conf = new QSettings (cfgFile);
     conf->insertSearchPath (QSettings::Unix, cfgFile);
 #endif
 #else
     conf = new Config (cfgFile, Config::File);
     conf->setGroup ("zsafePrefs");
 #endif
 #ifdef DESKTOP
 // #ifndef WIN32
     expandTree = conf->readBoolEntry(APP_KEY+"expandTree", false);
 // #endif
 #else
     expandTree = conf->readNumEntry(APP_KEY+"expandTree", 0);
 #endif
 #ifndef DESKTOP
     conf->setGroup ("zsafe");
 #endif
 
     QPixmap copy_img((const char**) copy_xpm);
     QPixmap cut_img((const char**) cut_xpm);
     QPixmap edit_img((const char**) edit_xpm);
     QPixmap editdelete_img((const char**) editdelete_xpm);
     QPixmap find_img((const char**) find_xpm);
     QPixmap folder_open_img((const char**) folder_open_xpm);
     QPixmap help_icon_img((const char**) help_icon_xpm);
     QPixmap new_img((const char**) new_xpm);
     QPixmap paste_img((const char**) paste_xpm);
     QPixmap quit_icon_img((const char**) quit_icon_xpm);
     QPixmap save_img((const char**) save_xpm);
     QPixmap trash_img((const char**) trash_xpm);
     QPixmap expand_img((const char**) expand_xpm);
     QPixmap export_img((const char**) export_xpm);
     QPixmap import_img((const char**) import_xpm);
 
     QPixmap bank_cards( ( const char** ) bank_cards_data );
     QPixmap passwords( ( const char** ) passwords_data );
     QPixmap software( ( const char** ) software_data );
     QPixmap general( ( const char** ) general_data );
     if ( !name )
     setName( "ZSafe" );
 
 #ifdef DESKTOP
diff --git a/noncore/comm/keypebble/krfbbuffer.cpp b/noncore/comm/keypebble/krfbbuffer.cpp
index f1cb929..92918d4 100644
--- a/noncore/comm/keypebble/krfbbuffer.cpp
+++ b/noncore/comm/keypebble/krfbbuffer.cpp
@@ -1,203 +1,200 @@
 #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 "krfbconnection.h"
-#include "krfbserver.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 scaleFactor=decoder->con->options()->scaleFactor;
   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 );
   }
 
 	if (scaleFactor > 1) {
 		 p.drawImage( x/scaleFactor, y/scaleFactor, img.smoothScale(w/scaleFactor,h/scaleFactor) );
 		 emit updated( x/scaleFactor, y/scaleFactor, w/scaleFactor, h/scaleFactor );
 	} 
 	else {
 		 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 bc71c90..75cba68 100644
--- a/noncore/comm/keypebble/krfbcanvas.cpp
+++ b/noncore/comm/keypebble/krfbcanvas.cpp
@@ -1,209 +1,200 @@
 #include "krfbconnection.h"
 #include "krfbcanvas.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 <qpoint.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( loggedIn() ),
 	    this, SLOT( loggedIn() ) );
 
     loggedIn_ = false;
 
 		//QPEApplication::setStylusOperation(viewport(), QPEApplication::RightOnHold);
 
     viewport()->setFocusPolicy( QWidget::StrongFocus );
     viewport()->setFocus();
 
     nextRightClick=0;
     nextDoubleClick=0;
 }
 
 KRFBCanvas::~KRFBCanvas()
 {
 }
 
 
 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" );
       return;
   }
 
   QCString host = url.host().latin1();
   int display = url.port();
 
 //  connection_->connectTo( host, display );
 }
 
 void KRFBCanvas::closeConnection()
 {
   loggedIn_ = false;
   connection_->disconnect();
 
   viewport()->setMouseTracking( false );
   viewport()->setBackgroundMode( PaletteDark );
   setBackgroundMode( PaletteDark );
   update();
 }
 
 
 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_ ) {
 			QPixmap p;
 
     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 (nextDoubleClick) {
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonPress, e->pos(),LeftButton,LeftButton));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonRelease, e->pos(),LeftButton,0));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonRelease, e->pos(),LeftButton,0));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonPress, e->pos(),NoButton,NoButton));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonRelease, e->pos(),NoButton,0));
   } if (nextRightClick) {
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonPress, e->pos(),RightButton,RightButton));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonRelease, e->pos(),RightButton,0));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonPress, e->pos(),NoButton,NoButton));
     connection_->buffer()->mouseEvent( &QMouseEvent(QEvent::MouseButtonRelease, e->pos(),NoButton,0));
   } else if ( loggedIn_ )
     connection_->buffer()->mouseEvent( e );
 
 }
 
 void KRFBCanvas::contentsMouseReleaseEvent( QMouseEvent *e )
 {
   if ( loggedIn_ && !nextRightClick && !nextDoubleClick) {
     connection_->buffer()->mouseEvent( e );
   }
 
   nextRightClick=0;
   nextDoubleClick=0;
 }
 
 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)
 {
 
   if ( loggedIn_ ) {
     connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyPress,Qt::Key_Control, 0,0));
     connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyPress,Qt::Key_Alt, 0,0));
 		connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyPress,Qt::Key_Delete, 0,0));
 		connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyRelease,Qt::Key_Control, 0,0));
 		connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyRelease,Qt::Key_Alt, 0,0));
     connection_->buffer()->keyPressEvent( &QKeyEvent(QEvent::KeyRelease,Qt::Key_Delete, 0,0));
 	}
 }
 
 void KRFBCanvas::markDoubleClick( void)
 {
   nextRightClick=1;
 }
 
 void KRFBCanvas::markRightClick( void)
 {
   nextRightClick=1;
 }
diff --git a/noncore/comm/keypebble/krfbconnection.cpp b/noncore/comm/keypebble/krfbconnection.cpp
index 389c836..e6c33c6 100644
--- a/noncore/comm/keypebble/krfbconnection.cpp
+++ b/noncore/comm/keypebble/krfbconnection.cpp
@@ -1,234 +1,233 @@
 #include <assert.h>
 #include <qsocket.h>
 #include <qtimer.h>
 #include <string.h>
 
 #include "krfbconnection.h"
 #include "krfblogin.h"
-#include "krfbserver.h"
 #include "krfbdecoder.h"
 #include "krfbbuffer.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;
 }
 
 KRFBConnection::~KRFBConnection()
 {
 		if ( ( currentState_ != Disconnected ) && ( currentState_ != Disconnecting ) && sock ) {
 				disconnectDone();
 		}
 		delete options_;
 }
 
 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..." );
 
 		currentState_ = Connecting;
 		sock->connectToHost( options_->hostname.latin1(), portBase_ + options_->display );
 }
 
 void KRFBConnection::disconnect()
 {
 		qWarning( "Disconnecting from server" );
 
 		if ( ( currentState_ != Disconnected )
 						&& ( currentState_ != Disconnecting )
 						&& sock ) {
 				currentState_ = Disconnecting;
 
 				connect( sock, SIGNAL( delayedCloseFinished() ), SLOT( disconnectDone() ) );
 				sock->close();
 
 				if ( sock->state() != QSocket::Closing )
 						disconnectDone();
 		}
 }
 
 void KRFBConnection::disconnectDone()
 {
 		currentState_ = Disconnected;
 		delete sock;
 		sock = 0;
 		minData_ = 0;
 		delete updater;
 		delete decoder_;
 		delete buffer_;
 		emit disconnected();
 }
 
 void KRFBConnection::gotSocketConnection()
 {
 		currentState_ = LoggingIn;
 
 		qWarning( "Connected, logging in..." );
 
 		static QString statusMsg = tr( "Connected" );
 		emit statusChanged( statusMsg );
 
 		// Do some login stuff
 		login = new KRFBLogin( this );
 }
 
 void KRFBConnection::gotRFBConnection()
 {
 		qWarning( "Logged into server" );
 
 		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_ );
 
 		connect( decoder_, SIGNAL( status( const QString & ) ),
 						this, SIGNAL( statusChanged( const QString & ) ) );
 		emit loggedIn();
 
 		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 );
 
 		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 );
 
 		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() ) );
 		}
 }
 
 int KRFBConnection::read( void *buf, int sz )
 {
 		return sock->readBlock( (char *)  buf, sz );
 }
 
 int KRFBConnection::write( void *buf, int sz )
 {
 		return sock->writeBlock( (const char *) buf, sz );
 }
 
 KRFBConnection::State KRFBConnection::state() const
 {
 		return currentState_;
 }
 
 void KRFBConnection::setPortBase( int base )
 {
 		portBase_ = base;
 }
 
 int KRFBConnection::portBase() const
 {
 		return portBase_;
 }
 
 void KRFBConnection::updateTimer()
 {
 		decoder_->sendUpdateRequest( true );
 }
 
 void KRFBConnection::refresh()
 {
 		decoder_->sendUpdateRequest( false );
 }
 
 void KRFBConnection::sendCutText( const QString &text )
 {
 		decoder_->sendCutEvent( text );
 }
 
 const QUrl &KRFBConnection::url()
 {
 		url_.setProtocol( "vnc" );
 		url_.setPort( display() );
 		url_.setHost( host() );
 		url_.setPath( "/" );
 
 		return url_;
 }
diff --git a/noncore/comm/keypebble/krfbdecoder.cpp b/noncore/comm/keypebble/krfbdecoder.cpp
index c43aed5..2c9ad71 100644
--- a/noncore/comm/keypebble/krfbdecoder.cpp
+++ b/noncore/comm/keypebble/krfbdecoder.cpp
@@ -1,397 +1,391 @@
 #include "krfbconnection.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 initialization..." );
   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 );
 
   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();
     }
diff --git a/noncore/comm/keypebble/krfblogin.cpp b/noncore/comm/keypebble/krfblogin.cpp
index 0d2a205..0b4a757 100644
--- a/noncore/comm/keypebble/krfblogin.cpp
+++ b/noncore/comm/keypebble/krfblogin.cpp
@@ -1,254 +1,253 @@
 #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 & ) ) );
 
 
   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->options_->password.isNull() ) {
     qWarning( "krfblogin needs a password" );
     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() );
   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/krfbserver.cpp b/noncore/comm/keypebble/krfbserver.cpp
index b47534e..fda81a1 100644
--- a/noncore/comm/keypebble/krfbserver.cpp
+++ b/noncore/comm/keypebble/krfbserver.cpp
@@ -1,41 +1,40 @@
-#include <qpe/config.h>
 #include <qpe/qpeapplication.h>
 #include "krfbserver.h"
 
 KRFBServer::KRFBServer()
 {
 	QString name;
 	QString hostname;
 	QString password;
 	display=0;
 
 	scaleFactor=1;
 
   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 2fa8d1f..c678edf 100644
--- a/noncore/comm/keypebble/kvnc.cpp
+++ b/noncore/comm/keypebble/kvnc.cpp
@@ -1,292 +1,279 @@
-#include <qiconset.h>
-#include <qdialog.h>
-#include <qpixmap.h>
-#include <qdom.h>
 #include <qaction.h>
-#include <qmenubar.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()
 {
 		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(  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 );
 
 		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);
 		if ( QPEApplication::execDialog( &dlg )) {
 				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);
 			if ( QPEApplication::execDialog( &dlg ) ) {
 					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 )
 				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/kvncbookmarkdlg.cpp b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
index 8556d49..ef2fa12 100644
--- a/noncore/comm/keypebble/kvncbookmarkdlg.cpp
+++ b/noncore/comm/keypebble/kvncbookmarkdlg.cpp
@@ -1,223 +1,209 @@
-#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, const char * name, WFlags f ) 
 
 : 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();
 						else if (key=="scalefactor") 
 								server->scaleFactor=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';
 					t << "\tscalefactor=" << server->scaleFactor << '\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
index cd55bb0..420c816 100644
--- a/noncore/comm/keypebble/kvncconndlg.cpp
+++ b/noncore/comm/keypebble/kvncconndlg.cpp
@@ -1,94 +1,86 @@
-#include <qframe.h>
-#include <qvbox.h>
 #include <qcheckbox.h>
 #include <qcombobox.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, WStyle_ContextHelp )
 {
     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 );
 
 		for (int i=0; i < scaleFactor->count(); ++i) {
 				if (scaleFactor->text(i).toInt()==tmpOptions.scaleFactor) {
 						scaleFactor->setCurrentItem(i);
 				}
 		}
 
 		// 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 );
 		    
 		serverPassword->setEchoMode(QLineEdit::Password);
 
 		connect(togglePassword, SIGNAL( stateChanged(int) ), this, SLOT( showPassword(int) ) );
 
 
 }
 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();
 		tmpOptions.scaleFactor = scaleFactor->currentText().toInt();
 
 		if (!serverBookmark->text().isEmpty()) {
        if ( options) {
           *options=tmpOptions;
         }
     }
 }
 
 void KVNCConnDlg::showPassword(int show)
 {
 		if (show)
 				serverPassword->setEchoMode(QLineEdit::Normal);
 		else
 			serverPassword->setEchoMode(QLineEdit::Password);
 }
diff --git a/noncore/comm/keypebble/main.cpp b/noncore/comm/keypebble/main.cpp
index 11f67fc..fc34099 100644
--- a/noncore/comm/keypebble/main.cpp
+++ b/noncore/comm/keypebble/main.cpp
@@ -1,10 +1,9 @@
 
 
 
-#include <qpe/qpeapplication.h>
 #include "kvnc.h"
 #include <opie/oapplicationfactory.h>
 
 
 
 OPIE_EXPORT_APP( OApplicationFactory<KVNC> )
diff --git a/noncore/comm/mobilemsg/mobilemsg.cpp b/noncore/comm/mobilemsg/mobilemsg.cpp
index 707872e..9a4db35 100644
--- a/noncore/comm/mobilemsg/mobilemsg.cpp
+++ b/noncore/comm/mobilemsg/mobilemsg.cpp
@@ -1,38 +1,33 @@
 #include "mobilemsg.h"
-#include <qpushbutton.h>
 
-#include <qpe/qpeapplication.h>
 
-#include <qlistbox.h>
-#include <qpushbutton.h>
-#include <qlayout.h>
 
 
 /* 
  *  Constructs a MobileMsg which is a child of 'parent', with the 
  *  name 'name' and widget flags set to 'f' 
  */
 MobileMsg::MobileMsg( QWidget* parent,  const char* name, WFlags fl )
     : MobileMsgBase( parent, name, fl )
 {
     //connect(add, SIGNAL(clicked()), this, SLOT(goodBye()));
     //connect(remove, SIGNAL(clicked()), this, SLOT(goodBye()));
     //connect(props, SIGNAL(clicked()), this, SLOT(goodBye()));
     //connect(settings, SIGNAL(selectionChanged()), this, SLOT(goodBye()) );
 }
 
 /*  
  *  Destroys the object and frees any allocated resources
  */
 MobileMsg::~MobileMsg()
 {
     // no need to delete child widgets, Qt does it all for us
 }
 
 /*
  *  A simple slot... not very interesting.
  */
 void MobileMsg::goodBye()
 {
     close();
 }
diff --git a/noncore/decorations/liquid/liquid.cpp b/noncore/decorations/liquid/liquid.cpp
index ef2ac3c..0bd4b1d 100644
--- a/noncore/decorations/liquid/liquid.cpp
+++ b/noncore/decorations/liquid/liquid.cpp
@@ -1,138 +1,136 @@
 #include "liquid.h"
 
 #include <qapplication.h>
-#include <qpainter.h>
-#include <qpalette.h>
 #include <qdrawutil.h>
 
 
 LiquidDecoInterface::LiquidDecoInterface ( ) 
 {
 }
     
 LiquidDecoInterface::~LiquidDecoInterface ( )
 {
 }
 
 
 
 QString LiquidDecoInterface::name ( ) const
 {
 	return qApp-> translate ( "Decoration", "Liquid" );
 }
 
 
 QPixmap LiquidDecoInterface::icon ( ) const
 {
 	return QPixmap ( );
 }            
         
 void LiquidDecoInterface::drawArea( Area a, QPainter *p, const WindowData *wd ) const
 {
 	QRect r = wd-> rect;
 	int th = metric ( TitleHeight, wd );
 
 	switch ( a ) {
 		case WindowDecorationInterface::Border: {
 			const QColorGroup &cg = wd-> palette. active ( );
 			qDrawWinPanel ( p, r. x ( ) - metric ( LeftBorder, wd ),
 				r. y ( ) - th - metric ( TopBorder, wd ),
 				r. width ( ) + metric ( LeftBorder, wd ) + metric ( RightBorder, wd ),
 				r. height ( ) + th + metric ( TopBorder,wd) + metric ( BottomBorder, wd ),
 				cg, false, &cg. brush ( QColorGroup::Background ));
 			break;
 		}
 		case WindowDecorationInterface::Title: {
 			const QColorGroup &cg = wd-> palette. active ( );
 			
 			QBrush titleBrush;
 			QPen   titleLines1, titleLines2;
 
 			titleBrush = cg. brush (( wd-> flags & WindowData::Active ) ? QColorGroup::Highlight : QColorGroup::Background );
 			titleLines1 = titleBrush. color ( ). dark ( 105 );
 			titleLines2 = titleBrush. color ( ). dark ( 103 );
 			
 			p-> fillRect ( r. x ( ), r. y ( ) - th, r. width ( ), th, titleBrush );
 			for ( int i = r.y()-th; i < r.y(); i += 4 ) {
 				p-> setPen ( titleLines1 );
 				p-> drawLine ( r. left ( ), i, r. right ( ), i );
 				p-> setPen ( titleLines2 );
 				p-> drawLine ( r. left ( ), i+1, r. right ( ), i+1 );
 			}
 			break;
 		}
 		case WindowDecorationInterface::TitleText: {
 			QColor textcol = wd-> palette. active ( ). color (( wd-> flags & WindowData::Active ) ? QColorGroup::HighlightedText : QColorGroup::Text );
 			QColor shadecol = ( qGray ( textcol. rgb ( ) ) > 128 ) ? textcol. dark ( 230 ) : textcol.light( 300 );
 			if ( textcol == shadecol ) {
 				if ( qGray ( shadecol. rgb ( ) ) < 128 )
 					shadecol = QColor ( 225, 225, 225 );
 				else
 					shadecol = QColor ( 30, 30, 30 );
 			}			
 			QColor fillcol = wd-> palette. active ( ). color (( wd-> flags & WindowData::Active ) ? QColorGroup::Highlight : QColorGroup::Background );
 			QColor bordercol = fillcol. dark ( 110 );
 			fillcol = fillcol. light ( 110 );
 			
 			QRect tr ( r.x ( ) + 3 + metric ( HelpWidth, wd ), r. top ( ) - th,
 				r. width ( ) - metric ( OKWidth, wd ) - metric ( CloseWidth, wd ), th );
 
 			QFont f = p-> font ( );
 			f. setWeight ( QFont::Bold );
 			p-> setFont ( f );                        
 						
 			QRect br = p-> boundingRect ( tr, QPainter::AlignCenter, wd-> caption );
 			int trh2 = tr. height ( ) / 2;
 			
 			int align = QPainter::AlignCenter;
 
 			if ( br. width ( ) + 2 * trh2 > tr. width ( ) ) {
 				br. setLeft ( tr. left ( ) + trh2 );
 				br. setWidth ( tr. width ( ) - 2 * trh2 );
 			
 				align = QPainter::AlignLeft | QPainter::AlignVCenter;
 			}
 			
 			p-> setBrush ( fillcol );
 			p-> setPen ( bordercol /*Qt::NoPen*/ );
 			p->	drawChord ( br. left ( ) - trh2, tr. top ( ), 2 * trh2, tr. height ( ), 90*16, 180*16 );
 			p->	drawChord ( br. right ( ) + 1 - trh2, tr. top ( ), 2 * trh2, tr. height ( ), 90*16, -180*16 );
 
 			p-> fillRect ( br.left() - 1, tr. top ( ), br. width ( ) + 2, tr. height ( ), fillcol);
 				
 			p-> setPen ( shadecol );
 			p-> drawText ( br, align, wd-> caption );
 			p-> setPen ( textcol );
 			br. moveBy ( -1, -1 );
 			p-> drawText ( br, align, wd-> caption );
 			break;
 		}
 		default: {
 			WindowDecorationInterface::drawArea ( a, p, wd );
 			break;
 		}
 	}
 }
 
 QRESULT LiquidDecoInterface::queryInterface ( const QUuid &uuid, QUnknownInterface **iface )
 {
 	*iface = 0;
 	
 	if ( uuid == IID_QUnknown )
 		*iface = this;
 	else if ( uuid == IID_WindowDecoration )
 		*iface = this;
 	else
 	    return QS_FALSE;
 	
 	if ( *iface )
 		(*iface)-> addRef ( );
 		
 	return QS_OK;
 }
 
 Q_EXPORT_INTERFACE()
 {
 	Q_CREATE_INSTANCE( LiquidDecoInterface )
 }