11 files changed, 94 insertions, 68 deletions
diff --git a/core/apps/textedit/textedit.cpp b/core/apps/textedit/textedit.cpp
index 759e440..61beac5 100644
--- a/core/apps/textedit/textedit.cpp
+++ b/core/apps/textedit/textedit.cpp
@@ -281,784 +281,785 @@ TextEdit::TextEdit( QWidget *parent, const char *name, WFlags f )
    nAdvanced = new QAction( tr("Prompt on Exit"),
                             QString::null, 0, this, 0 );
    connect( nAdvanced, SIGNAL( toggled(bool) ),
             this, SLOT( doPrompt(bool) ) );
    nAdvanced->setToggleAction(true);
    nAdvanced->addTo( advancedMenu );
    desktopAction = new QAction( tr("Always open linked file"),
                                 QString::null, 0, this, 0 );
    connect( desktopAction, SIGNAL( toggled(bool) ),
             this, SLOT( doDesktop(bool) ) );
    desktopAction->setToggleAction(true);
    desktopAction->addTo( advancedMenu);
    filePermAction = new QAction( tr("File Permissions"),
                                  QString::null, 0, this, 0 );
    connect( filePermAction, SIGNAL( toggled(bool) ),
             this, SLOT( doFilePerms(bool) ) );
    filePermAction->setToggleAction(true);
    filePermAction->addTo( advancedMenu);
    searchBarAction = new QAction( tr("Search Bar Open"),
                                   QString::null, 0, this, 0 );
    connect( searchBarAction, SIGNAL( toggled(bool) ),
             this, SLOT( setSearchBar(bool) ) );
    searchBarAction->setToggleAction(true);
    searchBarAction->addTo( advancedMenu);
    nAutoSave = new QAction( tr("Auto Save 5 min."),
                                   QString::null, 0, this, 0 );
    connect( nAutoSave, SIGNAL( toggled(bool) ),
             this, SLOT( doTimer(bool) ) );
    nAutoSave->setToggleAction(true);
    nAutoSave->addTo( advancedMenu);
    //font->insertSeparator();
    //font->insertItem(tr("About"), this, SLOT( doAbout()) );
    mb->insertItem( tr( "File" ), file );
    mb->insertItem( tr( "Edit" ), edit );
    mb->insertItem( tr( "View" ), font );
    searchBar = new QToolBar(this);
    addToolBar( searchBar,  "Search", QMainWindow::Top, true );
    searchBar->setHorizontalStretchable( true );
    searchEdit = new QLineEdit( searchBar, "searchEdit" );
    searchBar->setStretchableWidget( searchEdit );
    connect( searchEdit, SIGNAL( textChanged(const QString&) ),
       this, SLOT( search() ) );
    a = new QAction( tr( "Find Next" ), Opie::Core::OResource::loadPixmap( "next", Opie::Core::OResource::SmallIcon ),
                     QString::null, 0, this, 0 );
    connect( a, SIGNAL( activated() ), this, SLOT( findNext() ) );
    a->addTo( searchBar );
    a->addTo( edit );
    a = new QAction( tr( "Close Find" ), Opie::Core::OResource::loadPixmap( "close", Opie::Core::OResource::SmallIcon ),
                     QString::null, 0, this, 0 );
    connect( a, SIGNAL( activated() ), this, SLOT( findClose() ) );
    a->addTo( searchBar );
    edit->insertSeparator();
    a = new QAction( tr( "Delete" ), Opie::Core::OResource::loadPixmap( "close", Opie::Core::OResource::SmallIcon ),
                     QString::null, 0, this, 0 );
    connect( a, SIGNAL( activated() ), this, SLOT( editDelete() ) );
    a->addTo( edit );
    searchBar->hide();
    editor = new QpeEditor( this );
    setCentralWidget( editor );
    editor->setFrameStyle( QFrame::Panel | QFrame::Sunken );
    connect( editor, SIGNAL( textChanged() ),
             this, SLOT( editorChanged() ) );
    QPEApplication::setStylusOperation( editor, QPEApplication::RightOnHold);
    Config cfg("TextEdit");
    cfg. setGroup ( "Font" );
    QFont defaultFont = editor-> font ( );
    QString family = cfg. readEntry     ( "Family", defaultFont. family ( ));
    int size       = cfg. readNumEntry  ( "Size",   defaultFont. pointSize ( ));
    int weight     = cfg. readNumEntry  ( "Weight", defaultFont. weight ( ));
    bool italic    = cfg. readBoolEntry ( "Italic", defaultFont. italic ( ));
    defaultFont = QFont ( family, size, weight, italic );
    editor-> setFont ( defaultFont );
 //    updateCaption();
    cfg.setGroup ( "View" );
    promptExit = cfg.readBoolEntry ( "PromptExit", false );
    openDesktop = cfg.readBoolEntry ( "OpenDesktop", true );
    filePerms = cfg.readBoolEntry ( "FilePermissions", false );
    useSearchBar = cfg.readBoolEntry ( "SearchBar", false );
    startWithNew =  cfg.readBoolEntry ( "startNew", true);
    featureAutoSave = cfg.readBoolEntry( "autosave", false);
    if(useSearchBar) searchBarAction->setOn(true);
    if(promptExit)  nAdvanced->setOn( true );
    if(openDesktop) desktopAction->setOn( true );
    if(filePerms) filePermAction->setOn( true );
    if(startWithNew) nStart->setOn( true );
    if(featureAutoSave) nAutoSave->setOn(true);
 //       {
 //           doTimer(true);
 //       }
    bool wrap = cfg. readBoolEntry ( "Wrap", true );
    wa-> setOn ( wrap );
    setWordWrap ( wrap );
 /////////////////
    if( qApp->argc() > 1) {
        currentFileName=qApp->argv()[1];
        QFileInfo fi(currentFileName);
        if(fi.baseName().left(1) == "") {
            openDotFile(currentFileName);
        } else {
            openFile(currentFileName);
        }
    } else {
    edited1=false;
            openDotFile("");
    }
    viewSelection = cfg.readNumEntry( "FileView", 0 );
 }
 TextEdit::~TextEdit() {
    if( edited1 && !promptExit) {
                                switch( savePrompt() ) {
                                        case 1: {
                                                        saveAs();
                                        }
                                                        break;
                                };
                }
    delete editor;
 }
 void TextEdit::closeEvent(QCloseEvent *) {
    if(  promptExit) {
                                switch( savePrompt() ) {
                                        case 1: {
                                                        saveAs();
                                                        qApp->quit();
                                        }
                                                        break;
                                        case 2: {
                                                        qApp->quit();
                                        }
                                                        break;
                                        case -1:
                                                        break;
                                };
                }
    else
        qApp->quit();
 }
 void TextEdit::cleanUp() {
    Config cfg ( "TextEdit" );
    cfg. setGroup ( "Font" );
    QFont f = editor->font();
    cfg.writeEntry ( "Family", f. family ( ));
    cfg.writeEntry ( "Size",   f. pointSize ( ));
    cfg.writeEntry ( "Weight", f. weight ( ));
    cfg.writeEntry ( "Italic", f. italic ( ));
    cfg.setGroup ( "View" );
    cfg.writeEntry ( "Wrap", editor->wordWrap() == QMultiLineEdit::WidgetWidth );
    cfg.writeEntry ( "FileView", viewSelection );
    cfg.writeEntry ( "PromptExit", promptExit );
    cfg.writeEntry ( "OpenDesktop", openDesktop );
    cfg.writeEntry ( "FilePermissions", filePerms );
    cfg.writeEntry ( "SearchBar", useSearchBar );
    cfg.writeEntry ( "startNew", startWithNew );
 }
 void TextEdit::accept() {
        if( edited1)
            saveAs();
     qApp->quit();
 }
 void TextEdit::zoomIn() {
    setFontSize(editor->font().pointSize()+1,false);
 }
 void TextEdit::zoomOut() {
    setFontSize(editor->font().pointSize()-1,true);
 }
 void TextEdit::setFontSize(int sz, bool round_down_not_up) {
    int s=10;
    for (int i=0; i<nfontsizes; i++) {
  if ( fontsize[i] == sz ) {
      s = sz;
      break;
  } else if ( round_down_not_up ) {
      if ( fontsize[i] < sz )
    s = fontsize[i];
  } else {
      if ( fontsize[i] > sz ) {
    s = fontsize[i];
    break;
      }
  }
    }
    QFont f = editor->font();
    f.setPointSize(s);
    editor->setFont(f);
    zin->setEnabled(s != fontsize[nfontsizes-1]);
    zout->setEnabled(s != fontsize[0]);
 }
 void TextEdit::setBold(bool y) {
    QFont f = editor->font();
    f.setBold(y);
    editor->setFont(f);
 }
 void TextEdit::setItalic(bool y) {
    QFont f = editor->font();
    f.setItalic(y);
    editor->setFont(f);
 }
 void TextEdit::setWordWrap(bool y) {
    bool state = editor->edited();
    QString captionStr = caption();
    bool b1 = edited1;
    bool b2 = edited;
    editor->setWordWrap(y ? QMultiLineEdit::WidgetWidth : QMultiLineEdit::NoWrap );
    editor->setEdited( state );
    edited1=b1;
    edited=b2;
    setCaption(captionStr);
 }
 void TextEdit::setSearchBar(bool b) {
    useSearchBar=b;
    Config cfg("TextEdit");
    cfg.setGroup("View");
    cfg.writeEntry ( "SearchBar", b );
    searchBarAction->setOn(b);
    if(b)
        searchBar->show();
    else
        searchBar->hide();
    editor->setFocus();
 }
 void TextEdit::fileNew() {
 //     if( !bFromDocView  ) {
 //         saveAs();
 //     }
    newFile(DocLnk());
 }
 void TextEdit::fileOpen() {
    Config cfg("TextEdit");
    cfg. setGroup ( "View" );
    QMap<QString, QStringList> map;
    map.insert(tr("All"), QStringList() );
    QStringList text;
    text << "text/*";
    map.insert(tr("Text"), text );
    text << "*";
    map.insert(tr("All"), text );
    QString str = OFileDialog::getOpenFileName( 2,
                                                QString::null ,
                                                QString::null, map);
    if( !str.isEmpty() && QFile(str).exists() && !QFileInfo(str).isDir() )
    {
       openFile( str );
    }
    else
        updateCaption();
 }
 void TextEdit::doSearchBar() {
    if(!useSearchBar)
        searchBar->hide();
    else
        searchBar->show();
 }
 #if 0
 void TextEdit::slotFind() {
    FindDialog frmFind( tr("Text Editor"), this );
    connect( &frmFind, SIGNAL(signalFindClicked(const QString&,bool,bool,int)),
       editor, SLOT(slotDoFind(const QString&,bool,bool)));
    //case sensitive, backwards, [category]
    connect( editor, SIGNAL(notFound()),
       &frmFind, SLOT(slotNotFound()) );
    connect( editor, SIGNAL(searchWrapped()),
       &frmFind, SLOT(slotWrapAround()) );
    frmFind.exec();
 }
 #endif
 void TextEdit::fileRevert() {
    clear();
    fileOpen();
 }
 void TextEdit::editCut() {
 #ifndef QT_NO_CLIPBOARD
    editor->cut();
 #endif
 }
 void TextEdit::editCopy() {
 #ifndef QT_NO_CLIPBOARD
    editor->copy();
 #endif
 }
 void TextEdit::editPaste() {
 #ifndef QT_NO_CLIPBOARD
    editor->paste();
 #endif
 }
 void TextEdit::editFind() {
    searchBar->show();
    searchEdit->setFocus();
 }
 void TextEdit::findNext() {
    editor->find( searchEdit->text(), false, false );
 }
 void TextEdit::findClose() {
    searchBar->hide();
 }
 void TextEdit::search() {
    editor->find( searchEdit->text(), false, false );
 }
 void TextEdit::newFile( const DocLnk &f ) {
    DocLnk nf = f;
    nf.setType("text/plain");
    clear();
    setWState (WState_Reserved1 );
    editor->setFocus();
    doc = new DocLnk(nf);
    currentFileName = "Unnamed";
    odebug << "newFile "+currentFileName << oendl;
    updateCaption( currentFileName);
 //    editor->setEdited( false);
 }
 void TextEdit::openDotFile( const QString &f ) {
    if(!currentFileName.isEmpty()) {
-    currentFileName=f;
+        currentFileName=f;
-    odebug << "openFile dotfile " + currentFileName << oendl;
+        odebug << "openFile dotfile " + currentFileName << oendl;
-    QString txt;
+        QString txt;
-    QFile file(f);
+        QFile file(f);
-    file.open(IO_ReadWrite);
+        if (!file.open(IO_ReadWrite))
-    QTextStream t(&file);
+            owarn << "Failed to open file " << file.name() << oendl;
-    while ( !t.atEnd()) {
+        else {
-        txt+=t.readLine()+"\n";
+            QTextStream t(&file);
-    }
+            while ( !t.atEnd()) {
-    editor->setText(txt);
+                txt+=t.readLine()+"\n";
-    editor->setEdited( false);
+            }
-    edited1=false;
+            editor->setText(txt);
-    edited=false;
+            editor->setEdited( false);
+            edited1=false;
+            edited=false;
+        }
    }
    updateCaption( currentFileName);
 }
 void TextEdit::openFile( const QString &f ) {
  odebug << "filename is "+ f << oendl;
  QString filer;
  QFileInfo fi( f);
 //    bFromDocView = true;
  if(f.find(".desktop",0,true) != -1 && !openDesktop )
    {
      switch ( QMessageBox::warning(this,tr("Text Editor"),tr("Text Editor has detected<BR>you selected a <B>.desktop</B>file.<BR>Open<B>.desktop</B> file or <B>linked</B> file?"),tr(".desktop File"),tr("Linked Document"),0,1,1) )
        {
        case 0: //desktop
          filer = f;
          break;
        case 1: //linked
          DocLnk sf(f);
          filer = sf.file();
          break;
        };
    }
  else if(fi.baseName().left(1) == "")
    {
      odebug << "opening dotfile" << oendl;
      currentFileName=f;
      openDotFile(currentFileName);
      return;
    }
  /*
   * The problem is a file where Config(f).isValid() and it does not
   * end with .desktop will be treated as desktop file
   */
  else if (f.find(".desktop",0,true) != -1 )
    {
      DocLnk sf(f);
      filer = sf.file();
      if(filer.right(1) == "/")
          filer = f;
    }
  else
      filer = f;
      DocLnk nf;
      nf.setType("text/plain");
      nf.setFile(filer);
      currentFileName=filer;
      nf.setName(fi.baseName());
      openFile(nf);
      odebug << "openFile string "+currentFileName << oendl;
  showEditTools();
    // Show filename in caption
  QString name = filer;
  int sep = name.findRev( '/' );
  if ( sep > 0 )
    name = name.mid( sep+1 );
  updateCaption( name );
 }
 void TextEdit::openFile( const DocLnk &f ) {
 //    clear();
 //    bFromDocView = true;
    FileManager fm;
    QString txt;
    currentFileName=f.file();
    odebug << "openFile doclnk " + currentFileName << oendl;
    if ( !fm.loadFile( f, txt ) ) {
          // ####### could be a new file
        odebug << "Cannot open file" << oendl;
    }
 //    fileNew();
    if ( doc )
        delete doc;
    doc = new DocLnk(f);
    editor->setText(txt);
    editor->setEdited( false);
    edited1=false;
    edited=false;
    doc->setName(currentFileName);
    updateCaption();
    setTimer();
 }
 void TextEdit::showEditTools() {
    menu->show();
    editBar->show();
    if(!useSearchBar)
        searchBar->hide();
    else
        searchBar->show();
    setWState (WState_Reserved1 );
 }
 /*!
  unprompted save */
 bool TextEdit::save() {
                QString name, file;
    odebug << "saveAsFile " + currentFileName << oendl;
    if(currentFileName.isEmpty()) {
        saveAs();
        return false;
    }
                name = currentFileName;
                if(doc) {
                                file = doc->file();
                                odebug << "saver file "+file << oendl;
                                name = doc->name();
                                odebug << "File named "+name << oendl;
                } else {
                                file = currentFileName;
        name = QFileInfo(currentFileName).baseName();
                 }
    QString rt = editor->text();
    if( !rt.isEmpty() ) {
        if(name.isEmpty()) {
            saveAs();
        } else {
            currentFileName = name;
            odebug << "saveFile "+currentFileName << oendl;
            struct stat buf;
            mode_t mode;
            stat(file.latin1(), &buf);
            mode = buf.st_mode;
            if(!fileIs) {
                doc->setName( name);
                FileManager fm;
                if ( !fm.saveFile( *doc, rt ) ) {
                                                                                QMessageBox::message(tr("Text Edit"),tr("Save Failed"));
                    return false;
                }
            } else {
                odebug << "regular save file" << oendl;
                QFile f(file);
                                                                if( f.open(IO_WriteOnly)) {
                                                                                QCString crt = rt.utf8();
                                                                                f.writeBlock(crt,crt.length());
                                                                } else {
                                                                                QMessageBox::message(tr("Text Edit"),tr("Write Failed"));
                                                                                return false;
                                                                }
            }
            editor->setEdited( false);
            edited1=false;
            edited=false;
            if(caption().left(1)=="*")
                                                                setCaption(caption().right(caption().length()-1));
            chmod( file.latin1(), mode);
        }
        return true;
    }
    return false;
 }
 /*!
  prompted save */
 bool TextEdit::saveAs() {
    if(caption() == tr("Text Editor"))
        return false;
    odebug << "saveAsFile " + currentFileName << oendl;
      // case of nothing to save...
 //     if ( !doc && !currentFileName.isEmpty()) {
 // //|| !bFromDocView)
 //         odebug << "no doc" << oendl;
 //         return true;
 //     }
 //     if ( !editor->edited() ) {
 //         delete doc;
 //         doc = 0;
 //         return true;
 //     }
    QString rt = editor->text();
    odebug << currentFileName << oendl;
    if( currentFileName.isEmpty()
        || currentFileName == tr("Unnamed")
        || currentFileName == tr("Text Editor")) {
        odebug << "do silly TT filename thing" << oendl;
 //        if ( doc && doc->name().isEmpty() ) {
        QString pt = rt.simplifyWhiteSpace();
        int i = pt.find( ' ' );
        QString docname = pt;
        if ( i > 0 )
            docname = pt.left( i );
          // remove "." at the beginning
        while( docname.startsWith( "." ) )
            docname = docname.mid( 1 );
        docname.replace( QRegExp("/"), "_" );
          // cut the length. filenames longer than that
          //don't make sense and something goes wrong when they get too long.
        if ( docname.length() > 40 )
            docname = docname.left(40);
        if ( docname.isEmpty() )
            docname = tr("Unnamed");
        if(doc) doc->setName(docname);
        currentFileName=docname;
 //         }
 //         else
 //             odebug << "hmmmmmm" << oendl;
    }
    QMap<QString, QStringList> map;
    map.insert(tr("All"), QStringList() );
    QStringList text;
    text << "text/*";
    map.insert(tr("Text"), text );
    text << "*";
    map.insert(tr("All"), text );
    QFileInfo cuFi( currentFileName);
    QString filee = cuFi.fileName();
    QString dire = cuFi.dirPath();
    if(dire==".")
        dire = QPEApplication::documentDir();
    QString str;
    if( !featureAutoSave) {
                                str = OFileDialog::getSaveFileName( 2,
                                                                                                                                                                                dire,
                                                                                                                                                                                filee, map);
                } else
        str = currentFileName;
    if(!str.isEmpty()) {
        QString fileNm=str;
        odebug << "saving filename "+fileNm << oendl;
        QFileInfo fi(fileNm);
        currentFileName=fi.fileName();
        if(doc)
 //        QString file = doc->file();
 //        doc->removeFiles();
            delete doc;
                                DocLnk nf;
                                nf.setType("text/plain");
                                nf.setFile( fileNm);
                                doc = new DocLnk(nf);
 //        editor->setText(rt);
                                odebug << "Saving file as "+currentFileName << oendl;
                                doc->setName( fi.baseName() /*currentFileName*/);
                                updateCaption( currentFileName);
                                FileManager fm;
                                if ( !fm.saveFile( *doc, rt ) ) {
                                                QMessageBox::message(tr("Text Edit"),tr("Save Failed"));
                                                return false;
                                }
                                if( filePerms ) {
                                                filePermissions *filePerm;
                                                filePerm = new filePermissions(this,
                                                                                                                                                                         tr("Permissions"),true,
                                                                                                                                                                         0,(const QString &)fileNm);
                                                QPEApplication::execDialog( filePerm );
                                                if( filePerm)
                                                                delete  filePerm;
                                }
 //        }
        editor->setEdited( false);
        edited1 = false;
        edited = false;
        if(caption().left(1)=="*")
            setCaption(caption().right(caption().length()-1));
        return true;
    }
    odebug << "returning false" << oendl;
    currentFileName = "";
    return false;
 } //end saveAs
 void TextEdit::clear() {
    delete doc;
    doc = 0;
    editor->clear();
 }
 void TextEdit::updateCaption( const QString &name ) {
    if ( name.isEmpty() )
        setCaption( tr("Text Editor") );
    else {
        QString s = name;
        if ( s.isNull() )
            s = doc->name();
        if ( s.isEmpty()  ) {
            s = tr( "Unnamed" );
            currentFileName=s;
        }
 //         if(s.left(1) == "/")
 //             s = s.right(s.length()-1);
        setCaption( tr("%1 - Text Editor").arg( s ) );
    }
 }
 void TextEdit::setDocument(const QString& fileref) {
    if(fileref != "Unnamed") {
        currentFileName=fileref;
        odebug << "setDocument" << oendl;
         QFileInfo fi(currentFileName);
         odebug << "basename:"+fi.baseName()+": current filenmame "+currentFileName << oendl;
         if( (fi.baseName().left(1)).isEmpty() ) {
        openDotFile(currentFileName);
         } else {
             odebug << "setDoc open" << oendl;
             bFromDocView = true;
             openFile(fileref);
             editor->setEdited(true);
             edited1=false;
             edited=true;
               //   fromSetDocument=false;
 //    doSearchBar();
        }
    }
    updateCaption( currentFileName);
 }
 void TextEdit::changeFont() {
  QDialog *d = new QDialog ( this, "FontDialog", true );
  d-> setCaption ( tr( "Choose font" ));
  QBoxLayout *lay = new QVBoxLayout ( d );
  OFontSelector *ofs = new OFontSelector ( true, d );
  lay-> addWidget ( ofs );
  ofs-> setSelectedFont ( editor-> font ( ));
    if ( QPEApplication::execDialog( d ) == QDialog::Accepted )
      editor-> setFont ( ofs-> selectedFont ( ));
    delete d;
 }
 void TextEdit::editDelete() {
    switch ( QMessageBox::warning(this,tr("Text Editor"),
                                  tr("Do you really want<BR>to <B>delete</B> "
                                     "the current file\nfrom the disk?<BR>This is "
                                     "<B>irreversable!</B>"),
                                  tr("Yes"),tr("No"),0,0,1) ) {
      case 0:
          if(doc) {
              doc->removeFiles();
              clear();
              setCaption( tr("Text Editor") );
          }
          break;
      case 1:
            // exit
          break;
    };
 }
 void TextEdit::changeStartConfig( bool b ) {
    startWithNew=b;
    Config cfg("TextEdit");
    cfg.setGroup("View");
    cfg.writeEntry("startNew",b);
    update();
 }
 void TextEdit::editorChanged() {
 //    odebug << "editor changed" << oendl;
    if( /*editor->edited() &&*/ /*edited && */!edited1) {
        setCaption( "*"+caption());
        edited1=true;
    }
    edited=true;
 }
 void TextEdit::receive(const QCString&msg, const QByteArray &) {
    odebug << "QCop "+msg << oendl;
  if ( msg == "setDocument(QString)" ) {
diff --git a/core/launcher/qprocess_unix.cpp b/core/launcher/qprocess_unix.cpp
index 97c0460..3125bcc 100644
--- a/core/launcher/qprocess_unix.cpp
+++ b/core/launcher/qprocess_unix.cpp
@@ -1,700 +1,704 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 // Solaris redefines connect -> __xnet_connect with _XOPEN_SOURCE_EXTENDED.
 #if defined(connect)
 #undef connect
 #endif
 #include "qprocess.h"
 /* OPIE */
 #include <opie2/odebug.h>
 using namespace Opie::Core;
 /* QT */
 #ifndef QT_NO_PROCESS
 #include <qapplication.h>
 #include <qqueue.h>
 #include <qlist.h>
 #include <qsocketnotifier.h>
 #include <qtimer.h>
 #include <qregexp.h>
 #include "qcleanuphandler_p.h"
 /* STD */
 #include <stdlib.h>
 #include <unistd.h>
 #include <signal.h>
 #include <sys/socket.h>
 #include <sys/ioctl.h>
 #include <sys/wait.h>
 #include <sys/fcntl.h>
 #include <errno.h>
 #ifdef Q_OS_MACX
 #include <sys/time.h>
 #endif
 #include <sys/resource.h>
 #ifdef __MIPSEL__
 # ifndef SOCK_DGRAM
 #  define SOCK_DGRAM 1
 # endif
 # ifndef SOCK_STREAM
 #  define SOCK_STREAM 2
 # endif
 #endif
 //#define QT_QPROCESS_DEBUG
 #ifdef Q_C_CALLBACKS
 extern "C" {
 #endif // Q_C_CALLBACKS
 #define QT_SIGNAL_RETTYPE       void
 #define QT_SIGNAL_ARGS          int
 #define QT_SIGNAL_IGNORE        SIG_IGN
  QT_SIGNAL_RETTYPE qt_C_sigchldHnd(QT_SIGNAL_ARGS);
  QT_SIGNAL_RETTYPE qt_C_sigpipeHnd(QT_SIGNAL_ARGS);
 #ifdef Q_C_CALLBACKS
 }
 #endif // Q_C_CALLBACKS
 class QProc;
 class QProcessManager;
 class QProcessPrivate
 {
 public:
    QProcessPrivate();
    ~QProcessPrivate();
    void closeOpenSocketsForChild();
    void newProc( pid_t pid, QProcess *process );
    QByteArray bufStdout;
    QByteArray bufStderr;
    QQueue<QByteArray> stdinBuf;
    QSocketNotifier *notifierStdin;
    QSocketNotifier *notifierStdout;
    QSocketNotifier *notifierStderr;
    ssize_t stdinBufRead;
    QProc *proc;
    bool exitValuesCalculated;
    bool socketReadCalled;
    static QProcessManager *procManager;
 };
 /***********************************************************************
 *
 * QProc
 *
 **********************************************************************/
 /*
  The class QProcess does not necessarily map exactly to the running
  child processes: if the process is finished, the QProcess class may still be
  there; furthermore a user can use QProcess to start more than one process.
  The helper-class QProc has the semantics that one instance of this class maps
  directly to a running child process.
 */
 class QProc
 {
 public:
    QProc( pid_t p, QProcess *proc=0 ) : pid(p), process(proc)
    {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProc: Constructor for pid " << pid << " and QProcess " << process << "" << oendl;
 #endif
    socketStdin = 0;
    socketStdout = 0;
    socketStderr = 0;
    }
    ~QProc()
    {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProc: Destructor for pid " << pid << " and QProcess " << process << "" << oendl;
 #endif
    if ( process != 0 ) {
        if ( process->d->notifierStdin )
          process->d->notifierStdin->setEnabled( FALSE );
        if ( process->d->notifierStdout )
        process->d->notifierStdout->setEnabled( FALSE );
        if ( process->d->notifierStderr )
        process->d->notifierStderr->setEnabled( FALSE );
        process->d->proc = 0;
    }
    if( socketStdin != 0 )
      ::close( socketStdin );
    // ### close these sockets even on parent exit or is it better only on
    // sigchld (but what do I have to do with them on exit then)?
    if( socketStdout != 0 )
        ::close( socketStdout );
    if( socketStderr != 0 )
        ::close( socketStderr );
    }
    pid_t pid;
    int socketStdin;
    int socketStdout;
    int socketStderr;
    QProcess *process;
 };
 /***********************************************************************
 *
 * QProcessManager
 *
 **********************************************************************/
 class QProcessManager : public QObject
 {
    Q_OBJECT
 public:
    QProcessManager();
    ~QProcessManager();
    void append( QProc *p );
    void remove( QProc *p );
    void cleanup();
 public slots:
    void removeMe();
    void sigchldHnd( int );
 public:
    struct sigaction oldactChld;
    struct sigaction oldactPipe;
    QList<QProc> *procList;
    int sigchldFd[2];
 };
 QCleanupHandler<QProcessManager> qprocess_cleanup_procmanager;
 QProcessManager::QProcessManager()
 {
    procList = new QList<QProc>;
    procList->setAutoDelete( TRUE );
    // The SIGCHLD handler writes to a socket to tell the manager that
    // something happened. This is done to get the processing in sync with the
    // event reporting.
    if ( ::socketpair( AF_UNIX, SOCK_STREAM, 0, sigchldFd ) ) {
    sigchldFd[0] = 0;
    sigchldFd[1] = 0;
    } else {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: install socket notifier (" << sigchldFd[1] << ")" << oendl;
 #endif
    QSocketNotifier *sn = new QSocketNotifier( sigchldFd[1],
        QSocketNotifier::Read, this );
    connect( sn, SIGNAL(activated(int)),
        this, SLOT(sigchldHnd(int)) );
    sn->setEnabled( TRUE );
    }
    // install a SIGCHLD handler and ignore SIGPIPE
    struct sigaction act;
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: install a SIGCHLD handler" << oendl;
 #endif
    act.sa_handler = qt_C_sigchldHnd;
    sigemptyset( &(act.sa_mask) );
    sigaddset( &(act.sa_mask), SIGCHLD );
    act.sa_flags = SA_NOCLDSTOP;
 #if defined(SA_RESTART)
    act.sa_flags |= SA_RESTART;
 #endif
    if ( sigaction( SIGCHLD, &act, &oldactChld ) != 0 )
    owarn << "Error installing SIGCHLD handler" << oendl;
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: install a SIGPIPE handler (SIG_IGN)" << oendl;
 #endif
    /*
    Using qt_C_sigpipeHnd rather than SIG_IGN is a workaround
    for a strange problem where GNU tar (called by backuprestore)
    would hang on filesystem-full. Strangely, the qt_C_sigpipeHnd
    is never even called, yet this avoids the hang.
    */
    act.sa_handler = qt_C_sigpipeHnd;
    sigemptyset( &(act.sa_mask) );
    sigaddset( &(act.sa_mask), SIGPIPE );
    act.sa_flags = 0;
    if ( sigaction( SIGPIPE, &act, &oldactPipe ) != 0 )
    owarn << "Error installing SIGPIPE handler" << oendl;
 }
 QProcessManager::~QProcessManager()
 {
    delete procList;
    if ( sigchldFd[0] != 0 )
    ::close( sigchldFd[0] );
    if ( sigchldFd[1] != 0 )
    ::close( sigchldFd[1] );
    // restore SIGCHLD handler
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: restore old sigchild handler" << oendl;
 #endif
    if ( sigaction( SIGCHLD, &oldactChld, 0 ) != 0 )
    owarn << "Error restoring SIGCHLD handler" << oendl;
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: restore old sigpipe handler" << oendl;
 #endif
    if ( sigaction( SIGPIPE, &oldactPipe, 0 ) != 0 )
    owarn << "Error restoring SIGPIPE handler" << oendl;
 }
 void QProcessManager::append( QProc *p )
 {
    procList->append( p );
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: append process (procList.count(): " << procList->count() << ")" << oendl;
 #endif
 }
 void QProcessManager::remove( QProc *p )
 {
    procList->remove( p );
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager: remove process (procList.count(): " << procList->count() << ")" << oendl;
 #endif
    cleanup();
 }
 void QProcessManager::cleanup()
 {
    if ( procList->count() == 0 ) {
    QTimer::singleShot( 0, this, SLOT(removeMe()) );
    }
 }
 void QProcessManager::removeMe()
 {
    if ( procList->count() == 0 ) {
    qprocess_cleanup_procmanager.remove( &QProcessPrivate::procManager );
    QProcessPrivate::procManager = 0;
    delete this;
    }
 }
 void QProcessManager::sigchldHnd( int fd )
 {
    char tmp;
-    ::read( fd, &tmp, sizeof(tmp) );
+    if (::read( fd, &tmp, sizeof(tmp) ) < 0)
+#if defined(QT_QPROCESS_DEBUG)
+        odebug << "QProcessManager::sigchldHnd() failed dummy read of file descriptor" << oendl;
+#endif
+        ;
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessManager::sigchldHnd()" << oendl;
 #endif
    QProc *proc;
    QProcess *process;
    bool removeProc;
    proc = procList->first();
    while ( proc != 0 ) {
    removeProc = FALSE;
    process = proc->process;
    QProcess *process_exit_notify=0;
    if ( process != 0 ) {
        if ( !process->isRunning() ) {
 #if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcessManager::sigchldHnd() (PID: " << proc->pid << "): process exited (QProcess available)" << oendl;
 #endif
        // read pending data
        int nbytes = 0;
        if ( ::ioctl(proc->socketStdout, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) {
 #if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcessManager::sigchldHnd() (PID: " << proc->pid << "): reading " << nbytes << " bytes of pending data on stdout" << oendl;
 #endif
            process->socketRead( proc->socketStdout );
        }
        nbytes = 0;
        if ( ::ioctl(proc->socketStderr, FIONREAD, (char*)&nbytes)==0 && nbytes>0 ) {
 #if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcessManager::sigchldHnd() (PID: " << proc->pid << "): reading " << nbytes << " bytes of pending data on stderr" << oendl;
 #endif
            process->socketRead( proc->socketStderr );
        }
        if ( process->notifyOnExit )
            process_exit_notify = process;
        removeProc = TRUE;
        }
    } else {
        int status;
        if ( ::waitpid( proc->pid, &status, WNOHANG ) == proc->pid ) {
 #if defined(QT_QPROCESS_DEBUG)
        odebug << "QProcessManager::sigchldHnd() (PID: " << proc->pid << "): process exited (QProcess not available)" << oendl;
 #endif
        removeProc = TRUE;
        }
    }
    if ( removeProc ) {
        QProc *oldproc = proc;
        proc = procList->next();
        remove( oldproc );
    } else {
        proc = procList->next();
    }
    if ( process_exit_notify )
        emit process_exit_notify->processExited();
    }
 }
 #include "qprocess_unix.moc"
 /***********************************************************************
 *
 * QProcessPrivate
 *
 **********************************************************************/
 QProcessManager *QProcessPrivate::procManager = 0;
 QProcessPrivate::QProcessPrivate()
 {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessPrivate: Constructor" << oendl;
 #endif
    stdinBufRead = 0;
    notifierStdin = 0;
    notifierStdout = 0;
    notifierStderr = 0;
    exitValuesCalculated = FALSE;
    socketReadCalled = FALSE;
    proc = 0;
 }
 QProcessPrivate::~QProcessPrivate()
 {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcessPrivate: Destructor" << oendl;
 #endif
    if ( proc != 0 ) {
    if ( proc->socketStdin != 0 ) {
        ::close( proc->socketStdin );
        proc->socketStdin = 0;
    }
    proc->process = 0;
    }
    while ( !stdinBuf.isEmpty() ) {
    delete stdinBuf.dequeue();
    }
    delete notifierStdin;
    delete notifierStdout;
    delete notifierStderr;
 }
 /*
  Closes all open sockets in the child process that are not needed by the child
  process. Otherwise one child may have an open socket on standard input, etc.
  of another child.
 */
 void QProcessPrivate::closeOpenSocketsForChild()
 {
    if ( procManager != 0 ) {
    if ( procManager->sigchldFd[0] != 0 )
        ::close( procManager->sigchldFd[0] );
    if ( procManager->sigchldFd[1] != 0 )
        ::close( procManager->sigchldFd[1] );
    // close also the sockets from other QProcess instances
    QProc *proc;
    for ( proc=procManager->procList->first(); proc!=0; proc=procManager->procList->next() ) {
        ::close( proc->socketStdin );
        ::close( proc->socketStdout );
        ::close( proc->socketStderr );
    }
    }
 }
 void QProcessPrivate::newProc( pid_t pid, QProcess *process )
 {
    proc = new QProc( pid, process );
    if ( procManager == 0 ) {
    procManager = new QProcessManager;
    qprocess_cleanup_procmanager.add( &procManager );
    }
    // the QProcessManager takes care of deleting the QProc instances
    procManager->append( proc );
 }
 /***********************************************************************
 *
 * sigchld handler callback
 *
 **********************************************************************/
 QT_SIGNAL_RETTYPE qt_C_sigchldHnd( QT_SIGNAL_ARGS )
 {
    if ( QProcessPrivate::procManager == 0 )
    return;
    if ( QProcessPrivate::procManager->sigchldFd[0] == 0 )
    return;
    char a = 1;
    ::write( QProcessPrivate::procManager->sigchldFd[0], &a, sizeof(a) );
 }
 QT_SIGNAL_RETTYPE qt_C_sigpipeHnd( QT_SIGNAL_ARGS )
 {
    // Ignore (but in a way somehow different to SIG_IGN).
 }
 /***********************************************************************
 *
 * QProcess
 *
 **********************************************************************/
 /*!
  This private class does basic initialization.
 */
 void QProcess::init()
 {
    d = new QProcessPrivate();
    exitStat = 0;
    exitNormal = FALSE;
 }
 /*!
  This private class resets the process variables, etc. so that it can be used
  for another process to start.
 */
 void QProcess::reset()
 {
    delete d;
    d = new QProcessPrivate();
    exitStat = 0;
    exitNormal = FALSE;
    d->bufStdout.resize( 0 );
    d->bufStderr.resize( 0 );
 }
 QByteArray* QProcess::bufStdout()
 {
    if ( d->proc && d->proc->socketStdout ) {
    // ### can this cause a blocking behaviour (maybe do a ioctl() to see
    // if data is available)?
    socketRead( d->proc->socketStdout );
    }
    return &d->bufStdout;
 }
 QByteArray* QProcess::bufStderr()
 {
    if ( d->proc && d->proc->socketStderr ) {
    // ### can this cause a blocking behaviour (maybe do a ioctl() to see
    // if data is available)?
    socketRead( d->proc->socketStderr );
    }
    return &d->bufStderr;
 }
 void QProcess::consumeBufStdout( int consume )
 {
    uint n = d->bufStdout.size();
    if ( consume==-1 || (uint)consume >= n ) {
    d->bufStdout.resize( 0 );
    } else {
    QByteArray tmp( n - consume );
    memcpy( tmp.data(), d->bufStdout.data()+consume, n-consume );
    d->bufStdout = tmp;
    }
 }
 void QProcess::consumeBufStderr( int consume )
 {
    uint n = d->bufStderr.size();
    if ( consume==-1 || (uint)consume >= n ) {
    d->bufStderr.resize( 0 );
    } else {
    QByteArray tmp( n - consume );
    memcpy( tmp.data(), d->bufStderr.data()+consume, n-consume );
    d->bufStderr = tmp;
    }
 }
 /*!
  Destroys the class.
  If the process is running, it is NOT terminated! Standard input, standard
  output and standard error of the process are closed.
  You can connect the destroyed() signal to the kill() slot, if you want the
  process to be terminated automatically when the class is destroyed.
  \sa tryTerminate() kill()
 */
 QProcess::~QProcess()
 {
    delete d;
 }
 /*!
  Tries to run a process for the command and arguments that were specified with
  setArguments(), addArgument() or that were specified in the constructor. The
  command is searched in the path for executable programs; you can also use an
  absolute path to the command.
  If \a env is null, then the process is started with the same environment as
  the starting process. If \a env is non-null, then the values in the
  stringlist are interpreted as environment setttings of the form \c
  {key=value} and the process is started in these environment settings. For
  convenience, there is a small exception to this rule: under Unix, if \a env
  does not contain any settings for the environment variable \c
  LD_LIBRARY_PATH, then this variable is inherited from the starting process;
  under Windows the same applies for the enverionment varialbe \c PATH.
  Returns TRUE if the process could be started, otherwise FALSE.
  You can write data to standard input of the process with
  writeToStdin(), you can close standard input with closeStdin() and you can
  terminate the process tryTerminate() resp. kill().
  You can call this function even when there already is a running
  process in this object. In this case, QProcess closes standard input
  of the old process and deletes pending data, i.e., you loose all
  control over that process, but the process is not terminated. This applies
  also if the process could not be started. (On operating systems that have
  zombie processes, Qt will also wait() on the old process.)
  \sa launch() closeStdin()
 */
 bool QProcess::start( QStringList *env )
 {
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcess::start()" << oendl;
 #endif
    reset();
    int sStdin[2];
    int sStdout[2];
    int sStderr[2];
    // open sockets for piping
    if ( (comms & Stdin) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdin ) == -1 ) {
    return FALSE;
    }
    if ( (comms & Stderr) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStderr ) == -1 ) {
    return FALSE;
    }
    if ( (comms & Stdout) && ::socketpair( AF_UNIX, SOCK_STREAM, 0, sStdout ) == -1 ) {
    return FALSE;
    }
    // the following pipe is only used to determine if the process could be
    // started
    int fd[2];
    if ( pipe( fd ) < 0 ) {
    // non critical error, go on
    fd[0] = 0;
    fd[1] = 0;
    }
    // construct the arguments for exec
    QCString *arglistQ = new QCString[ _arguments.count() + 1 ];
    const char** arglist = new const char*[ _arguments.count() + 1 ];
    int i = 0;
    for ( QStringList::Iterator it = _arguments.begin(); it != _arguments.end(); ++it ) {
    arglistQ[i] = (*it).local8Bit();
    arglist[i] = arglistQ[i];
 #if defined(QT_QPROCESS_DEBUG)
    odebug << "QProcess::start(): arg " << i << " = " << arglist[i] << "" << oendl;
 #endif
    i++;
    }
    arglist[i] = 0;
    // Must make sure signal handlers are installed before exec'ing
    // in case the process exits quickly.
    if ( d->procManager == 0 ) {
    d->procManager = new QProcessManager;
    qprocess_cleanup_procmanager.add( &d->procManager );
    }
    // fork and exec
    QApplication::flushX();
    pid_t pid = fork();
    if ( pid == 0 ) {
    // child
    d->closeOpenSocketsForChild();
    if ( comms & Stdin ) {
        ::close( sStdin[1] );
        ::dup2( sStdin[0], STDIN_FILENO );
    }
    if ( comms & Stdout ) {
        ::close( sStdout[0] );
        ::dup2( sStdout[1], STDOUT_FILENO );
    }
    if ( comms & Stderr ) {
        ::close( sStderr[0] );
        ::dup2( sStderr[1], STDERR_FILENO );
    }
    if ( comms & DupStderr ) {
        ::dup2( STDOUT_FILENO, STDERR_FILENO );
    }
 #ifndef QT_NO_DIR
    ::chdir( workingDir.absPath().latin1() );
 #endif
    if ( fd[0] )
        ::close( fd[0] );
    if ( fd[1] )
        ::fcntl( fd[1], F_SETFD, FD_CLOEXEC ); // close on exec shows sucess
    if ( env == 0 ) { // inherit environment and start process
        ::execvp( arglist[0], (char*const*)arglist ); // ### cast not nice
    } else { // start process with environment settins as specified in env
        // construct the environment for exec
        int numEntries = env->count();
        bool setLibraryPath =
        env->grep( QRegExp( "^LD_LIBRARY_PATH=" ) ).isEmpty() &&
        getenv( "LD_LIBRARY_PATH" ) != 0;
        if ( setLibraryPath )
        numEntries++;
        QCString *envlistQ = new QCString[ numEntries + 1 ];
        const char** envlist = new const char*[ numEntries + 1 ];
        int i = 0;
        if ( setLibraryPath ) {
        envlistQ[i] = QString( "LD_LIBRARY_PATH=%1" ).arg( getenv( "LD_LIBRARY_PATH" ) ).local8Bit();
        envlist[i] = envlistQ[i];
        i++;
        }
        for ( QStringList::Iterator it = env->begin(); it != env->end(); ++it ) {
        envlistQ[i] = (*it).local8Bit();
        envlist[i] = envlistQ[i];
        i++;
diff --git a/core/launcher/server.cpp b/core/launcher/server.cpp
index 921b790..c45265a 100644
--- a/core/launcher/server.cpp
+++ b/core/launcher/server.cpp
@@ -1,1006 +1,1015 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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 "server.h"
 #include "serverapp.h"
 #include "startmenu.h"
 #include "launcher.h"
 #include "transferserver.h"
 #include "qcopbridge.h"
 #include "irserver.h"
 #include "packageslave.h"
 #include "calibrate.h"
 #include "qrsync.h"
 #include "syncdialog.h"
 #include "shutdownimpl.h"
 #include "applauncher.h"
 #if 0
 #include "suspendmonitor.h"
 #endif
 #include "documentlist.h"
 #include "qrr.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <opie2/odevicebutton.h>
 #include <opie2/odevice.h>
 #include <opie2/oprocess.h>
 #include <qtopia/applnk.h>
 #include <qtopia/private/categories.h>
 #include <qtopia/mimetype.h>
 #include <qtopia/config.h>
 #include <qtopia/resource.h>
 #include <qtopia/version.h>
 #include <qtopia/storage.h>
 #include <qtopia/qcopenvelope_qws.h>
 #include <qtopia/global.h>
 using namespace Opie::Core;
 /* QT */
 #include <qmainwindow.h>
 #include <qmessagebox.h>
 #include <qtimer.h>
 #include <qtextstream.h>
 #include <qwindowsystem_qws.h>
 #include <qgfx_qws.h>
 /* STD */
 #include <unistd.h>
 #include <stdlib.h>
 extern QRect qt_maxWindowRect;
 static QWidget *calibrate(bool)
 {
 #ifdef Q_WS_QWS
    Calibrate *c = new Calibrate;
    c->show();
    return c;
 #else
    return 0;
 #endif
 }
 #define FACTORY(T) \
    static QWidget *new##T( bool maximized ) { \
    QWidget *w = new T( 0, 0, QWidget::WDestructiveClose | QWidget::WGroupLeader ); \
    if ( maximized ) { \
        if ( qApp->desktop()->width() <= 350 ) { \
        w->showMaximized(); \
        } else { \
        w->resize( QSize( 300, 300 ) ); \
        } \
    } \
    w->show(); \
    return w; \
    }
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) FACTORY(b)
 #include "apps.h"
 #undef APP
 #endif // SINGLE_APP
 static Global::Command builtins[] = {
 #ifdef SINGLE_APP
 #define APP(a,b,c,d) { a, new##b, c, d },
 #include "apps.h"
 #undef APP
 #endif
    /* FIXME defines need to be defined*/
 #if !defined(OPIE_NO_BUILTIN_CALIBRATE)
        { "calibrate",          calibrate,          1, 0 }, // No tr
 #endif
 #if !defined(OPIE_NO_BUILTIN_SHUTDOWN)
    { "shutdown",           Global::shutdown,       1, 0 }, // No tr
 //  { "run",                run,            1, 0 }, // No tr
 #endif
    { 0,            calibrate,  0, 0 },
 };
 #ifdef QPE_HAVE_DIRECT_ACCESS
 extern void readyDirectAccess(QString cardInfo, QString installLocations);
 extern const char *directAccessQueueFile();
 #endif
 //---------------------------------------------------------------------------
 //===========================================================================
 Server::Server() :
    QWidget( 0, 0, WStyle_Tool | WStyle_Customize ),
    qcopBridge( 0 ),
    transferServer( 0 ),
    packageHandler( 0 ),
    syncDialog( 0 ),
    process( 0 )
 {
    Global::setBuiltinCommands(builtins);
    tid_xfer = 0;
    /* ### FIXME ### */
 /*    tid_today = startTimer(3600*2*1000);*/
    last_today_show = QDate::currentDate();
 #warning FIXME support TempScreenSaverMode
 #if 0
    tsmMonitor = new TempScreenSaverMode();
    connect( tsmMonitor, SIGNAL(forceSuspend()), qApp, SIGNAL(power()) );
 #endif
    serverGui = new Launcher;
    serverGui->createGUI();
    docList = new DocumentList( serverGui );
    appLauncher = new AppLauncher(this);
    connect(appLauncher, SIGNAL(launched(int,const QString&)), this, SLOT(applicationLaunched(int,const QString&)) );
    connect(appLauncher, SIGNAL(terminated(int,const QString&)), this, SLOT(applicationTerminated(int,const QString&)) );
    connect(appLauncher, SIGNAL(connected(const QString&)), this, SLOT(applicationConnected(const QString&)) );
    storage = new StorageInfo( this );
    connect( storage, SIGNAL(disksChanged()), this, SLOT(storageChanged()) );
 #ifdef QPE_HAVE_DIRECT_ACCESS
    QCopChannel *desktopChannel = new QCopChannel( "QPE/Desktop", this );
    connect( desktopChannel, SIGNAL(received( const QCString &, const QByteArray & )),
         this, SLOT(desktopMessage( const QCString &, const QByteArray & )) );
 #endif
    soundServerExited();
    // start services
    startTransferServer();
    (void) new IrServer( this );
    packageHandler = new PackageHandler( this );
    connect(qApp, SIGNAL(activate(const Opie::Core::ODeviceButton*,bool)),
            this,SLOT(activate(const Opie::Core::ODeviceButton*,bool)));
    setGeometry( -10, -10, 9, 9 );
    QCopChannel *channel = new QCopChannel("QPE/System", this);
    connect(channel, SIGNAL(received(const QCString&,const QByteArray&)),
        this, SLOT(systemMsg(const QCString&,const QByteArray&)) );
    QCopChannel *tbChannel = new QCopChannel( "QPE/TaskBar", this );
    connect( tbChannel, SIGNAL(received(const QCString&,const QByteArray&)),
        this, SLOT(receiveTaskBar(const QCString&,const QByteArray&)) );
    connect( qApp, SIGNAL(prepareForRestart()), this, SLOT(terminateServers()) );
    connect( qApp, SIGNAL(timeChanged()), this, SLOT(pokeTimeMonitors()) );
    preloadApps();
 }
 void Server::show()
 {
    ServerApplication::login(TRUE);
    QWidget::show();
 }
 Server::~Server()
 {
    serverGui->destroyGUI();
    delete docList;
    delete qcopBridge;
    delete transferServer;
    delete serverGui;
 #if 0
    delete tsmMonitor;
 #endif
 }
 static bool hasVisibleWindow(const QString& clientname, bool partial)
 {
 #ifdef QWS
    const QList<QWSWindow> &list = qwsServer->clientWindows();
    QWSWindow* w;
    for (QListIterator<QWSWindow> it(list); (w=it.current()); ++it) {
    if ( w->client()->identity() == clientname ) {
        if ( partial && !w->isFullyObscured() )
        return TRUE;
        if ( !partial && !w->isFullyObscured() && !w->isPartiallyObscured() ) {
 # if QT_VERSION < 0x030000
        QRect mwr = qt_screen->mapToDevice(qt_maxWindowRect,
            QSize(qt_screen->width(),qt_screen->height()) );
 # else
        QRect mwr = qt_maxWindowRect;
 # endif
        if ( mwr.contains(w->requested().boundingRect()) )
            return TRUE;
        }
    }
    }
 #endif
    return FALSE;
 }
 void Server::activate(const ODeviceButton* button, bool held)
 {
    Global::terminateBuiltin("calibrate"); // No tr
    OQCopMessage om;
    if ( held ) {
    om = button->heldAction();
    } else {
    om = button->pressedAction();
    }
    if ( om.channel() != "ignore" )
        om.send();
    // A button with no action defined, will return a null ServiceRequest.  Don't attempt
    // to send/do anything with this as it will crash
    /* ### FIXME */
 #if 0
    if ( !sr.isNull() ) {
    QString app = sr.app();
    bool vis = hasVisibleWindow(app, app != "qpe");
    if ( sr.message() == "raise()" && vis ) {
        sr.setMessage("nextView()");
    } else {
        // "back door"
        sr << (int)vis;
    }
    sr.send();
    }
 #endif
 }
 #ifdef Q_WS_QWS
 typedef struct KeyOverride {
    ushort scan_code;
    QWSServer::KeyMap map;
 };
 static const KeyOverride jp109keys[] = {
   { 0x03, { Qt::Key_2,                 '2'   , 0x22  , 0xffff  } },
   { 0x07, { Qt::Key_6,                 '6'   , '&'   , 0xffff  } },
   { 0x08, { Qt::Key_7,                 '7'   , '\''  , 0xffff  } },
   { 0x09, { Qt::Key_8,                 '8'   , '('   , 0xffff  } },
   { 0x0a, { Qt::Key_9,                 '9'   , ')'   , 0xffff  } },
   { 0x0b, { Qt::Key_0,                 '0'   , 0xffff, 0xffff  } },
   { 0x0c, { Qt::Key_Minus,             '-'   , '='   , 0xffff  } },
   { 0x0d, { Qt::Key_AsciiCircum,       '^'   , '~'   , '^'-64  } },
   { 0x1a, { Qt::Key_At,                '@'   , '`'   , 0xffff  } },
   { 0x1b, { Qt::Key_BraceLeft,         '['   , '{'   , '['-64  } },
   { 0x27, { Qt::Key_Semicolon,         ';'   , '+'   , 0xffff  } },
   { 0x28, { Qt::Key_Colon,             ':'   , '*'   , 0xffff  } },
   { 0x29, { Qt::Key_Zenkaku_Hankaku,   0xffff, 0xffff, 0xffff  } },
   { 0x2b, { Qt::Key_BraceRight,        ']'   , '}'   , ']'-64  } },
   { 0x70, { Qt::Key_Hiragana_Katakana, 0xffff, 0xffff, 0xffff  } },
   { 0x73, { Qt::Key_Backslash,         '\\'  , '_'   , 0xffff  } },
   { 0x79, { Qt::Key_Henkan,            0xffff, 0xffff, 0xffff  } },
   { 0x7b, { Qt::Key_Muhenkan,          0xffff, 0xffff, 0xffff  } },
   { 0x7d, { Qt::Key_yen,               0x00a5, '|'   , 0xffff  } },
   { 0x00, { 0,                         0xffff, 0xffff, 0xffff  } }
 };
 bool Server::setKeyboardLayout( const QString &kb )
 {
    //quick demo version that can be extended
    QIntDict<QWSServer::KeyMap> *om = 0;
    if ( kb == "us101" ) { // No tr
    om = 0;
    } else if ( kb == "jp109" ) {
    om = new QIntDict<QWSServer::KeyMap>(37);
    const KeyOverride *k = jp109keys;
    while ( k->scan_code ) {
        om->insert( k->scan_code, &k->map );
        k++;
    }
    }
    QWSServer::setOverrideKeys( om );
    return TRUE;
 }
 #endif
 void Server::systemMsg(const QCString &msg, const QByteArray &data)
 {
    QDataStream stream( data, IO_ReadOnly );
    if ( msg == "securityChanged()" ) {
    if ( transferServer )
       transferServer->authorizeConnections();
    if ( qcopBridge )
        qcopBridge->authorizeConnections();
 #warning FIXME support TempScreenSaverMode
 #if 0
    } else if ( msg == "setTempScreenSaverMode(int,int)" ) {
        int mode, pid;
        stream >> mode >> pid;
        tsmMonitor->setTempMode(mode, pid);
 #endif
    } else if ( msg == "linkChanged(QString)" ) {
        QString link;
        stream >> link;
        odebug << "desktop.cpp systemMsg -> linkchanged( " << link << " )" << oendl;
        docList->linkChanged(link);
    } else if (msg =="reforceDocuments()") {
        docList->reforceDocuments();
    } else if ( msg == "serviceChanged(QString)" ) {
        MimeType::updateApplications();
    } else if ( msg == "mkdir(QString)" ) {
        QString dir;
        stream >> dir;
        if ( !dir.isEmpty() )
            mkdir( dir );
    } else if ( msg == "rdiffGenSig(QString,QString)" ) {
        QString baseFile, sigFile;
        stream >> baseFile >> sigFile;
        QRsync::generateSignature( baseFile, sigFile );
    } else if ( msg == "rdiffGenDiff(QString,QString,QString)" ) {
        QString baseFile, sigFile, deltaFile;
        stream >> baseFile >> sigFile >> deltaFile;
        QRsync::generateDiff( baseFile, sigFile, deltaFile );
    } else if ( msg == "rdiffApplyPatch(QString,QString)" ) {
        QString baseFile, deltaFile;
        stream >> baseFile >> deltaFile;
+        bool fileWasCreated = false;
        if ( !QFile::exists( baseFile ) ) {
            QFile f( baseFile );
-            f.open( IO_WriteOnly );
+            fileWasCreated = f.open( IO_WriteOnly );
            f.close();
        }
-        QRsync::applyDiff( baseFile, deltaFile );
+        if ( fileWasCreated ) {
+            QRsync::applyDiff( baseFile, deltaFile );
 #ifndef QT_NO_COP
-        QCopEnvelope e( "QPE/Desktop", "patchApplied(QString)" );
+            QCopEnvelope e( "QPE/Desktop", "patchApplied(QString)" );
-        e << baseFile;
+            e << baseFile;
 #endif
+        } else {
+#ifndef QT_NO_COP
+            QCopEnvelope e( "QPE/Desktop", "patchUnapplied(QString)" );
+            e << baseFile;
+#endif
+        }
    } else if ( msg == "rdiffCleanup()" ) {
        mkdir( "/tmp/rdiff" );
        QDir dir;
        dir.setPath( "/tmp/rdiff" );
        QStringList entries = dir.entryList();
        for ( QStringList::Iterator it = entries.begin(); it != entries.end(); ++it )
            dir.remove( *it );
    } else if ( msg == "sendHandshakeInfo()" ) {
        QString home = getenv( "HOME" );
 #ifndef QT_NO_COP
        QCopEnvelope e( "QPE/Desktop", "handshakeInfo(QString,bool)" );
        e << home;
        int locked = (int) ServerApplication::screenLocked();
        e << locked;
 #endif
    } else  if ( msg == "sendVersionInfo()" ) {
    /*
     * @&$*! Qtopiadesktop relies on the major number
     * to start with 1. (or 2 as the case of version 2.1 will be)
     * we need to fake 1.7 to be able
     * to sync with Qtopiadesktop 1.7.
     * We'll send it Opie's version in the platform string for now,
     * until such time when QD gets rewritten correctly.
     */
        QCopEnvelope e( "QPE/Desktop", "versionInfo(QString,QString)" );
        QString opiename = "Opie "+QString(QPE_VERSION);
        QString QDVersion="1.7";
        e << QDVersion << opiename;
    } else if ( msg == "sendCardInfo()" ) {
 #ifndef QT_NO_COP
        QCopEnvelope e( "QPE/Desktop", "cardInfo(QString)" );
 #endif
        storage->update();
        const QList<FileSystem> &fs = storage->fileSystems();
        QListIterator<FileSystem> it ( fs );
        QString s;
        QString homeDir = getenv("HOME");
        QString homeFs, homeFsPath;
        for ( ; it.current(); ++it ) {
            int k4 = (*it)->blockSize()/256;
            if ( (*it)->isRemovable() ) {
            s += (*it)->name() + "=" + (*it)->path() + "/Documents " // No tr
                 + QString::number( (*it)->availBlocks() * k4/4 )
                 + "K " + (*it)->options() + ";";
            } else if ( homeDir.contains( (*it)->path() ) &&
                  (*it)->path().length() > homeFsPath.length() ) {
            homeFsPath = (*it)->path();
            homeFs =
                (*it)->name() + "=" + homeDir + "/Documents " // No tr
                + QString::number( (*it)->availBlocks() * k4/4 )
                + "K " + (*it)->options() + ";";
            }
        }
        if ( !homeFs.isEmpty() )
            s += homeFs;
 #ifndef QT_NO_COP
        e << s;
 #endif
    } else if ( msg == "sendInstallLocations()" ) {
 #ifndef QT_NO_COP
    QCopEnvelope e( "QPE/Desktop", "installLocations(QString)" );
    e << installLocationsString();
 #endif
    } else if ( msg == "sendSyncDate(QString)" ) {
        QString app;
        stream >> app;
        Config cfg( "qpe" );
        cfg.setGroup("SyncDate");
 #ifndef QT_NO_COP
        QCopEnvelope e( "QPE/Desktop", "syncDate(QString,QString)" );
        e  << app  << cfg.readEntry( app );
 #endif
        //odebug << "QPE/System sendSyncDate for " << app.latin1() << ": response "
        //       << cfg.readEntry( app ).latin1() << oendl;
    } else if ( msg == "setSyncDate(QString,QString)" ) {
        QString app, date;
        stream >> app >> date;
        Config cfg( "qpe" );
        cfg.setGroup("SyncDate");
        cfg.writeEntry( app, date );
        //odebug << "setSyncDate(QString,QString) " << app << " " << date << "" << oendl;
    } else if ( msg == "startSync(QString)" ) {
        QString what;
        stream >> what;
        delete syncDialog;
        syncDialog = new SyncDialog( this, what );
        syncDialog->show();
        connect( syncDialog, SIGNAL(cancel()), SLOT(cancelSync()) );
    } else if ( msg == "stopSync()") {
        delete syncDialog;
        syncDialog = 0;
    } else if (msg == "restoreDone(QString)") {
        docList->restoreDone();
    } else if ( msg == "getAllDocLinks()" ) {
        docList->sendAllDocLinks();
    }
 #ifdef QPE_HAVE_DIRECT_ACCESS
    else if ( msg == "prepareDirectAccess()" ) {
    prepareDirectAccess();
    } else if ( msg == "postDirectAccess()" ) {
    postDirectAccess();
    }
 #endif
 #ifdef Q_WS_QWS
 else if ( msg == "setMouseProto(QString)" ) {
        QString mice;
        stream >> mice;
        setenv("QWS_MOUSE_PROTO",mice.latin1(),1);
        qwsServer->openMouse();
    } else if ( msg == "setKeyboard(QString)" ) {
        QString kb;
        stream >> kb;
        setenv("QWS_KEYBOARD",kb.latin1(),1);
        qwsServer->openKeyboard();
    } else if ( msg == "setKeyboardAutoRepeat(int,int)" ) {
        int delay, period;
        stream >> delay >> period;
        qwsSetKeyboardAutoRepeat( delay, period );
        Config cfg( "qpe" );
        cfg.setGroup("Keyboard");
        cfg.writeEntry( "RepeatDelay", delay );
        cfg.writeEntry( "RepeatPeriod", period );
    } else if ( msg == "setKeyboardLayout(QString)" ) {
        QString kb;
        stream >> kb;
        setKeyboardLayout( kb );
        Config cfg( "qpe" );
        cfg.setGroup("Keyboard");
        cfg.writeEntry( "Layout", kb );
    } else if ( msg == "autoStart(QString)" ) {
        QString appName;
        stream >> appName;
        Config cfg( "autostart" );
        cfg.setGroup( "AutoStart" );
        if ( appName.compare("clear") == 0){
            cfg.writeEntry("Apps", "");
        }
    } else if ( msg == "autoStart(QString,QString)" ) {
        QString modifier, appName;
        stream >> modifier >> appName;
        Config cfg( "autostart" );
        cfg.setGroup( "AutoStart" );
        if ( modifier.compare("add") == 0 ){
            // only add if appname is entered
           if (!appName.isEmpty()) {
                cfg.writeEntry("Apps", appName);
            }
        } else if (modifier.compare("remove") == 0 ) {
            // need to change for multiple entries
            // actually remove is right now simular to clear, but in future there
            // should be multiple apps in autostart possible.
            QString checkName;
            checkName = cfg.readEntry("Apps", "");
            if (checkName == appName) {
                cfg.writeEntry("Apps", "");
            }
        }
        // case the autostart feature should be delayed
    } else if ( msg == "autoStart(QString,QString,QString)") {
        QString modifier, appName, delay;
        stream >> modifier >> appName >> delay;
        Config cfg( "autostart" );
        cfg.setGroup( "AutoStart" );
        if ( modifier.compare("add") == 0 ){
            // only add it appname is entered
            if (!appName.isEmpty()) {
                cfg.writeEntry("Apps", appName);
                cfg.writeEntry("Delay", delay);
            }
        }
    }
 #endif
 }
 QString Server::cardInfoString()
 {
    storage->update();
    const QList<FileSystem> &fs = storage->fileSystems();
    QListIterator<FileSystem> it ( fs );
    QString s;
    QString homeDir = getenv("HOME");
    QString homeFs, homeFsPath;
    for ( ; it.current(); ++it ) {
    int k4 = (*it)->blockSize()/256;
    if ( (*it)->isRemovable() ) {
        s += (*it)->name() + "=" + (*it)->path() + "/Documents " // No tr
         + QString::number( (*it)->availBlocks() * k4/4 )
         + "K " + (*it)->options() + ";";
    } else if ( homeDir.contains( (*it)->path() ) &&
          (*it)->path().length() > homeFsPath.length() ) {
        homeFsPath = (*it)->path();
        homeFs =
        (*it)->name() + "=" + homeDir + "/Documents " // No tr
        + QString::number( (*it)->availBlocks() * k4/4 )
        + "K " + (*it)->options() + ";";
    }
    }
    if ( !homeFs.isEmpty() )
    s += homeFs;
    return s;
 }
 QString Server::installLocationsString()
 {
    storage->update();
    const QList<FileSystem> &fs = storage->fileSystems();
    QListIterator<FileSystem> it ( fs );
    QString s;
    QString homeDir = getenv("HOME");
    QString homeFs, homeFsPath;
    for ( ; it.current(); ++it ) {
    int k4 = (*it)->blockSize()/256;
    if ( (*it)->isRemovable() ) {
        s += (*it)->name() + "=" + (*it)->path() + " " // No tr
         + QString::number( (*it)->availBlocks() * k4/4 )
         + "K " + (*it)->options() + ";";
    } else if ( homeDir.contains( (*it)->path() ) &&
            (*it)->path().length() > homeFsPath.length() ) {
        homeFsPath = (*it)->path();
        homeFs =
        (*it)->name() + "=" + homeDir + " " // No tr
        + QString::number( (*it)->availBlocks() * k4/4 )
        + "K " + (*it)->options() + ";";
    }
    }
    if ( !homeFs.isEmpty() )
    s = homeFs + s;
    return s;
 }
 void Server::receiveTaskBar(const QCString &msg, const QByteArray &data)
 {
    QDataStream stream( data, IO_ReadOnly );
    if ( msg == "reloadApps()" ) {
      docList->reloadAppLnks();
    } else if ( msg == "soundAlarm()" ) {
      ServerApplication::soundAlarm();
    } else if ( msg == "setLed(int,bool)" ) {
        int led, status;
        stream >> led >> status;
        QValueList <OLed> ll = ODevice::inst ( )-> ledList ( );
        if ( ll. count ( )) {
            OLed l = ll. contains ( Led_Mail ) ? Led_Mail : ll [0];
            bool canblink = ODevice::inst ( )-> ledStateList ( l ). contains ( Led_BlinkSlow );
            ODevice::inst ( )-> setLedState ( l, status ? ( canblink ? Led_BlinkSlow : Led_On ) : Led_Off );
        }
    }
 }
 void Server::cancelSync()
 {
 #ifndef QT_NO_COP
    QCopEnvelope e( "QPE/Desktop", "cancelSync()" );
 #endif
    delete syncDialog;
    syncDialog = 0;
 }
 bool Server::mkdir(const QString &localPath)
 {
    QDir fullDir(localPath);
    if (fullDir.exists())
    return true;
    // at this point the directory doesn't exist
    // go through the directory tree and start creating the direcotories
    // that don't exist; if we can't create the directories, return false
    QString dirSeps = "/";
    int dirIndex = localPath.find(dirSeps);
    QString checkedPath;
    // didn't find any seps; weird, use the cur dir instead
    if (dirIndex == -1) {
        //odebug << "No seperators found in path " << localPath << "" << oendl;
        checkedPath = QDir::currentDirPath();
    }
    while (checkedPath != localPath) {
    // no more seperators found, use the local path
    if (dirIndex == -1) {
        checkedPath = localPath;
    } else {
        // the next directory to check
        checkedPath = localPath.left(dirIndex) + "/";
        // advance the iterator; the next dir seperator
        dirIndex = localPath.find(dirSeps, dirIndex+1);
    }
    QDir checkDir(checkedPath);
    if (!checkDir.exists()) {
        //odebug << "mkdir making dir " << checkedPath << "" << oendl;
        if (!checkDir.mkdir(checkedPath)) {
        odebug << "Unable to make directory " << checkedPath << "" << oendl;
        return FALSE;
        }
    }
    }
    return TRUE;
 }
 void Server::styleChange( QStyle &s )
 {
    QWidget::styleChange( s );
 }
 void Server::startTransferServer()
 {
    if ( !qcopBridge ) {
       // start qcop bridge server
       qcopBridge = new QCopBridge( 4243 );
       if ( qcopBridge->ok() ) {
           // ... OK
           connect( qcopBridge, SIGNAL(connectionClosed(const QHostAddress&)),
               this, SLOT(syncConnectionClosed(const QHostAddress&)) );
       } else {
           delete qcopBridge;
           qcopBridge = 0;
       }
    }
    if ( !transferServer ) {
        // start transfer server
        transferServer = new TransferServer( 4242 );
        if ( transferServer->ok() ) {
            // ... OK
        } else {
            delete transferServer;
            transferServer = 0;
        }
        if ( !qcopBridge )
            tid_xfer = startTimer( 2000 );
    }
 }
 void Server::timerEvent( QTimerEvent *e )
 {
    if ( e->timerId() == tid_xfer ) {
        killTimer( tid_xfer );
        tid_xfer = 0;
        startTransferServer();
    }
 #if 0
    /* ### FIXME today startin */
    else if ( e->timerId() == tid_today ) {
        QDate today = QDate::currentDate();
        if ( today != last_today_show ) {
            last_today_show = today;
            Config cfg("today");
            cfg.setGroup("Start");
 #ifndef QPE_DEFAULT_TODAY_MODE
 #define QPE_DEFAULT_TODAY_MODE "Never"
 #endif
            if ( cfg.readEntry("Mode",QPE_DEFAULT_TODAY_MODE) == "Daily" ) {
            QCopEnvelope env(Service::channel("today"),"raise()");
            }
        }
    }
 #endif
 }
 void Server::terminateServers()
 {
    delete transferServer;
    delete qcopBridge;
    transferServer = 0;
    qcopBridge = 0;
 }
 void Server::syncConnectionClosed( const QHostAddress & )
 {
    odebug << "Lost sync connection" << oendl;
    delete syncDialog;
    syncDialog = 0;
 }
 void Server::pokeTimeMonitors()
 {
 #if 0
    // inform all TimeMonitors
    QStrList tms = Service::channels("TimeMonitor");
    for (const char* ch = tms.first(); ch; ch=tms.next()) {
    QString t = getenv("TZ");
    QCopEnvelope e(ch, "timeChange(QString)");
    e << t;
    }
 #endif
 }
 void Server::applicationLaunched(int, const QString &app)
 {
    serverGui->applicationStateChanged( app, ServerInterface::Launching );
 }
 void Server::applicationTerminated(int pid, const QString &app)
 {
    serverGui->applicationStateChanged( app, ServerInterface::Terminated );
 #if 0
    tsmMonitor->applicationTerminated( pid );
 #else
    Q_UNUSED( pid )
 #endif
 }
 void Server::applicationConnected(const QString &app)
 {
    serverGui->applicationStateChanged( app, ServerInterface::Running );
 }
 void Server::storageChanged()
 {
    system( "opie-update-symlinks" );
    serverGui->storageChanged( storage->fileSystems() );
    docList->storageChanged();
 }
 void Server::preloadApps()
 {
    Config cfg("Launcher");
    cfg.setGroup("Preload");
    QStringList apps = cfg.readListEntry("Apps",',');
    for (QStringList::ConstIterator it=apps.begin(); it!=apps.end(); ++it) {
 #ifndef QT_NO_COP
        QCopEnvelope e("QPE/Application/"+(*it).local8Bit(), "enablePreload()");
 #endif
    }
 }
 // This is only called if QPE_HAVE_DIRECT_ACCESS is defined
 void Server::prepareDirectAccess()
 {
    qDebug( "Server::prepareDirectAccess()" );
    // Put up a pretty dialog
    syncDialog = new SyncDialog( this, tr("USB Lock") );
    syncDialog->show();
    // Prevent the PDA from acting as a PDA
    terminateServers();
    // suspend the mtab monitor
 #ifndef QT_NO_COP
    {
    QCopEnvelope e( "QPE/Stabmon", "suspendMonitor()" );
    }
 #endif
    // send out a flush message
    // once flushes are done call runDirectAccess()
    // We just count the number of apps and set a timer.
    // Either the timer expires or the correct number of apps responds.
    // Note: quicklauncher isn't in the runningApps list but it responds
    //       to the flush so we start the counter at 1
    pendingFlushes = 1;
    directAccessRun = FALSE;
    for ( QMap<int,QString>::ConstIterator it =
        appLauncher->runningApplications().begin();
      it != appLauncher->runningApplications().end();
      ++it ) {
    pendingFlushes++;
    }
 #ifndef QT_NO_COP
    QCopEnvelope e1( "QPE/System", "flush()" );
 #endif
    QTimer::singleShot( 10000, this, SLOT(runDirectAccess()) );
 #warning FIXME support TempScreenSaverMode
 #if 0
    QPEApplication::setTempScreenSaverMode(QPEApplication::DisableSuspend);
 #endif
 }
 // This is only connected if QPE_HAVE_DIRECT_ACCESS is defined
 // It fakes the presence of Qtopia Desktop
 void Server::desktopMessage( const QCString &message, const QByteArray &data )
 {
    QDataStream stream( data, IO_ReadOnly );
    if ( message == "flushDone(QString)" ) {
    QString app;
    stream >> app;
    qDebug( "flushDone from %s", app.latin1() );
    if ( --pendingFlushes == 0 ) {
        qDebug( "pendingFlushes == 0, all the apps responded" );
        runDirectAccess();
    }
    } else if ( message == "installStarted(QString)" ) {
    QString package;
    stream >> package;
    qDebug( "\tInstall Started for package %s", package.latin1() );
    } else if ( message == "installStep(QString)" ) {
    QString step;
    stream >> step;
    qDebug( "\tInstall Step %s", step.latin1() );
    } else if ( message == "installDone(QString)" ) {
    QString package;
    stream >> package;
    qDebug( "\tInstall Finished for package %s", package.latin1() );
    } else if ( message == "installFailed(QString,int,QString)" ) {
    QString package, error;
    int status;
    stream >> package >> status >> error;
    qDebug( "\tInstall Failed for package %s with error code %d and error message %s",
        package.latin1(), status, error.latin1() );
    } else if ( message == "removeStarted(QString)" ) {
    QString package;
    stream >> package;
    qDebug( "\tRemove Started for package %s", package.latin1() );
    } else if ( message == "removeDone(QString)" ) {
    QString package;
    stream >> package;
    qDebug( "\tRemove Finished for package %s", package.latin1() );
    } else if ( message == "removeFailed(QString)" ) {
    QString package;
    stream >> package;
    qDebug( "\tRemove Failed for package %s", package.latin1() );
    }
    if ( qrr && qrr->waitingForMessages )
    qrr->desktopMessage( message, data );
 }
 // This is only connected if QPE_HAVE_DIRECT_ACCESS is defined
 void Server::runDirectAccess()
 {
 #ifdef QPE_HAVE_DIRECT_ACCESS
    // The timer must have fired after all the apps responded
    // with flushDone(). Just ignore it.
    if ( directAccessRun )
    return;
    directAccessRun = TRUE;
    ::readyDirectAccess(cardInfoString(), installLocationsString());
 #endif
 }
 // This is only called if QPE_HAVE_DIRECT_ACCESS is defined
 void Server::postDirectAccess()
 {
 #ifdef QPE_HAVE_DIRECT_ACCESS
    qDebug( "Server::postDirectAccess()" );
    // Categories may have changed
    QCopEnvelope e1( "QPE/System", "categoriesChanged()" );
    // Apps need to reload their data
    QCopEnvelope e2( "QPE/System", "reload()" );
    // Reload DocLinks
    docList->storageChanged();
    // Restart the PDA server stuff
    startTransferServer();
    // restart the mtab monitor
 #ifndef QT_NO_COP
    {
    QCopEnvelope e( "QPE/Stabmon", "restartMonitor()" );
    }
 #endif
    // Process queued requests
    const char *queueFile = ::directAccessQueueFile();
    QFile *file = new QFile( queueFile );
    if ( !file->exists() ) {
    delete file;
    // Get rid of the dialog
    if ( syncDialog ) {
        delete syncDialog;
        syncDialog = 0;
    }
 #warning FIXME support TempScreenSaverMode
 #if 0
    QPEApplication::setTempScreenSaverMode(QPEApplication::Enable);
 #endif
    } else {
    qrr = new QueuedRequestRunner( file, syncDialog );
    connect( qrr, SIGNAL(finished()),
         this, SLOT(finishedQueuedRequests()) );
    QTimer::singleShot( 100, qrr, SLOT(process()) );
    // qrr will remove the sync dialog later
    }
 #endif
 }
 void Server::finishedQueuedRequests()
 {
    if ( qrr->readyToDelete ) {
    delete qrr;
    qrr = 0;
    // Get rid of the dialog
    if ( syncDialog ) {
        delete syncDialog;
        syncDialog = 0;
    }
 #warning FIXME support TempScreenSaverMode
 #if 0
    QPEApplication::setTempScreenSaverMode(QPEApplication::Enable);
 #endif
    } else {
    qrr->readyToDelete = TRUE;
    QTimer::singleShot( 0, this, SLOT(finishedQueuedRequests()) );
    }
 }
 void Server::startSoundServer() {
    if ( !process ) {
        process = new Opie::Core::OProcess( this );
        connect(process, SIGNAL(processExited(Opie::Core::OProcess*)),
                SLOT(soundServerExited()));
    }
    process->clearArguments();
    *process << QPEApplication::qpeDir() + "bin/qss";
-    process->start();
+    if (!process->start())
+        owarn << "Sound server process did not start" << oendl;
 }
 void Server::soundServerExited() {
    QTimer::singleShot(5000, this, SLOT(startSoundServer()));
 }
diff --git a/core/settings/launcher/menusettings.cpp b/core/settings/launcher/menusettings.cpp
index 29ce841..d63b203 100644
--- a/core/settings/launcher/menusettings.cpp
+++ b/core/settings/launcher/menusettings.cpp
@@ -1,178 +1,181 @@
 /*
                     This file is part of the OPIE Project
               =.            Copyright (c)  2002 Trolltech AS <info@trolltech.com>
      .=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
     .>+-=
 _;:,   .>  :=|.         This file is free software; you can
 .> <`_,  > .  <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.--  :           the terms of the GNU General Public
 .="- .-=="i,   .._         License as published by the Free Software
 - .  .-<_>   .<>         Foundation; either version 2 of the License,
  ._= =}    :          or (at your option) any later version.
  .%`+i>    _;_.
  .i_,=:_.   -<s.       This file 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 General
 ..}^=.=    =    ;      Public License for more details.
 ++=  -.   .`   .:
 :   = ...= . :.=-        You should have received a copy of the GNU
 -.  .:....=;==+<;          General Public License along with this file;
 -_. . .  )=. =           see the file COPYING. If not, write to the
  --    :-=`           Free Software Foundation, Inc.,
                             59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
 */
 #include "menusettings.h"
 #include <qpe/config.h>
 #include <qpe/qlibrary.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/menuappletinterface.h>
 #include <qpe/qcopenvelope_qws.h>
+#include <opie2/odebug.h>
 #include <qdir.h>
 #include <qlistview.h>
 #include <qcheckbox.h>
 #include <qheader.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qwhatsthis.h>
 #include <stdlib.h>
 MenuSettings::MenuSettings ( QWidget *parent, const char *name )
        : QWidget ( parent, name )
 {
        m_applets_changed = false;
        QBoxLayout *lay = new QVBoxLayout ( this, 4, 4 );
        QLabel *l = new QLabel ( tr( "Load applets in O-Menu:" ), this );
        lay-> addWidget ( l );
        m_list = new QListView ( this );
        m_list-> addColumn ( "foobar" );
        m_list-> header ( )-> hide ( );
        lay-> addWidget ( m_list );
        m_menutabs = new QCheckBox ( tr( "Show Launcher tabs in O-Menu" ), this );
        lay-> addWidget ( m_menutabs );
        m_menusubpopup = new QCheckBox ( tr( "Show Applications in Subpopups" ), this );
        lay-> addWidget ( m_menusubpopup );
        QWhatsThis::add ( m_list, tr( "Check the applets that you want to have included in the O-Menu." ));
        QWhatsThis::add ( m_menutabs, tr( "Adds the contents of the Launcher Tabs as menus in the O-Menu." ));
        connect ( m_list, SIGNAL( clicked(QListViewItem*)), this, SLOT( appletChanged()));
        init ( );
 }
 void MenuSettings::init ( )
 {
        Config cfg ( "StartMenu" );
        cfg. setGroup ( "Applets" );
        QStringList exclude = cfg. readListEntry ( "ExcludeApplets", ',' );
        QString path = QPEApplication::qpeDir ( ) + "plugins/applets";
 #ifdef Q_OS_MACX
        QStringList list = QDir ( path, "lib*.dylib" ). entryList ( );
 #else
        QStringList list = QDir ( path, "lib*.so" ). entryList ( );
 #endif /* Q_OS_MACX */
        for ( QStringList::Iterator it = list. begin ( ); it != list. end ( ); ++it ) {
                QString name;
                QPixmap icon;
                MenuAppletInterface *iface = 0;
                QLibrary *lib = new QLibrary ( path + "/" + *it );
-                lib-> queryInterface ( IID_MenuApplet, (QUnknownInterface**) &iface );
+                QRESULT retVal = QS_OK;
+                if ((retVal = lib-> queryInterface ( IID_MenuApplet, (QUnknownInterface**)(&iface) )) != QS_OK )
+                        owarn << "queryInterface failed with " << retVal << oendl;
        if ( iface ) {
                        QString lang = getenv( "LANG" );
                        QTranslator *trans = new QTranslator ( qApp );
                        QString type = (*it). left ((*it). find ("."));
                        QString tfn = QPEApplication::qpeDir ( ) + "i18n/" + lang + "/" + type + ".qm";
                        if ( trans-> load ( tfn ))
                                qApp-> installTranslator ( trans );
                        else
                                delete trans;
                        name = iface-> name ( );
                        icon = iface-> icon ( ). pixmap ();
                        iface-> release ( );
                        lib-> unload ( );
                        QCheckListItem *item;
                        item = new QCheckListItem ( m_list, name, QCheckListItem::CheckBox );
                        if ( !icon. isNull ( ))
                                item-> setPixmap ( 0, icon );
                        item-> setOn ( exclude. find ( *it ) == exclude. end ( ));
                        m_applets [*it] = item;
                } else {
                        delete lib;
                }
        }
        cfg. setGroup ( "Menu" );
        m_menutabs->setChecked( cfg.readBoolEntry( "LauncherTabs", true ) );
        m_menusubpopup->setChecked( cfg.readBoolEntry( "LauncherSubPopup", true ) );
        m_menusubpopup->setEnabled( m_menutabs->isChecked() );
        connect( m_menutabs, SIGNAL( stateChanged(int) ), m_menusubpopup, SLOT( setEnabled(bool) ) );
 }
 void MenuSettings::appletChanged()
 {
        m_applets_changed = true;
 }
 void MenuSettings::accept ( )
 {
        bool apps_changed = false;
        Config cfg ( "StartMenu" );
        cfg. setGroup ( "Applets" );
        if ( m_applets_changed ) {
                QStringList exclude;
                QMap <QString, QCheckListItem *>::Iterator it;
                for ( it = m_applets. begin ( ); it != m_applets. end ( ); ++it ) {
                        if ( !(*it)-> isOn ( ))
                                exclude << it. key ( );
                }
                cfg. writeEntry ( "ExcludeApplets", exclude, ',' );
        }
        cfg. writeEntry ( "SafeMode", false );
        cfg. setGroup ( "Menu" );
        if ( m_menutabs-> isChecked ( ) != cfg. readBoolEntry ( "LauncherTabs", true )) {
                apps_changed = true;
                cfg. writeEntry ( "LauncherTabs", m_menutabs-> isChecked ( ));
        }
                if ( m_menusubpopup-> isChecked ( ) != cfg. readBoolEntry ( "LauncherSubPopup", true )) {
                 apps_changed = true;
                cfg. writeEntry ( "LauncherSubPopup", m_menusubpopup-> isChecked ( ));
        }
        cfg. write ( );
        if ( m_applets_changed ) {
                QCopEnvelope ( "QPE/TaskBar", "reloadApplets()" );
                m_applets_changed = false;
        }
        if ( apps_changed ) {
                                 // currently use reloadApplets() since reloadApps is now used exclusive for server
                                 // to refresh the tabs. But what we want here is also a refresh of the startmenu entries
                QCopEnvelope ( "QPE/TaskBar", "reloadApps()" );
                                QCopEnvelope ( "QPE/TaskBar", "reloadApplets()" );
        }
 }
diff --git a/core/settings/launcher/taskbarsettings.cpp b/core/settings/launcher/taskbarsettings.cpp
index 861ff3a..c2b82b9 100644
--- a/core/settings/launcher/taskbarsettings.cpp
+++ b/core/settings/launcher/taskbarsettings.cpp
@@ -1,176 +1,179 @@
 /*
 � � � � � � � �              This file is part of the OPIE Project
               =.            Copyright (c)  2002 Trolltech AS <info@trolltech.com>
 � � � � � � �.=l.            Copyright (c)  2002 Robert Griebl <sandman@handhelds.org>
 � � � � � �.>+-=
 �_;:, � � .> � �:=|.         This file is free software; you can
 .> <`_, � > �. � <=          redistribute it and/or modify it under
 :`=1 )Y*s>-.-- � :           the terms of the GNU General Public
 .="- .-=="i, � � .._         License as published by the Free Software
 �- . � .-<_> � � .<>         Foundation; either version 2 of the License,
 � � �._= =} � � � :          or (at your option) any later version.
 � � .%`+i> � � � _;_.
 � � .i_,=:_. � � �-<s.       This file 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 General
 ..}^=.= � � � = � � � ;      Public License for more details.
 ++= � -. � � .` � � .:
 �: � � = �...= . :.=-        You should have received a copy of the GNU
 �-. � .:....=;==+<;          General Public License along with this file;
 � -_. . . � )=. �=           see the file COPYING. If not, write to the
 � � -- � � � �:-=`           Free Software Foundation, Inc.,
                             59 Temple Place - Suite 330,
                             Boston, MA 02111-1307, USA.
 */
 #include "taskbarsettings.h"
 /* OPIE */
 #include <qpe/config.h>
 #include <qpe/qlibrary.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/taskbarappletinterface.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <opie2/odebug.h>
 /* QT */
 #include <qdir.h>
 #include <qlistview.h>
 #include <qheader.h>
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qwhatsthis.h>
 /* STD */
 #include <stdlib.h>
 TaskbarSettings::TaskbarSettings ( QWidget *parent, const char *name )
    : QWidget ( parent, name )
 {
    m_applets_changed = false;
    QBoxLayout *lay = new QVBoxLayout ( this, 4, 4 );
    QLabel *l = new QLabel ( tr( "Load applets in Taskbar:" ), this );
    lay-> addWidget ( l );
    m_list = new QListView ( this );
    m_list-> addColumn ( "foobar" );
    m_list-> header ( )-> hide ( );
    lay-> addWidget ( m_list );
    QWhatsThis::add ( m_list, tr( "Check the applets that you want displayed in the Taskbar." ));
    connect ( m_list, SIGNAL( clicked(QListViewItem*)), this, SLOT( appletChanged()));
    init ( );
 }
 void TaskbarSettings::init ( )
 {
    Config cfg ( "Taskbar" );
    cfg. setGroup ( "Applets" );
    QStringList exclude = cfg. readListEntry ( "ExcludeApplets", ',' );
    QString path = QPEApplication::qpeDir ( ) + "plugins/applets";
 #ifdef Q_OS_MACX
    QStringList list = QDir ( path, "lib*.dylib" ). entryList ( );
 #else
    QStringList list = QDir ( path, "lib*.so" ). entryList ( );
 #endif /* Q_OS_MACX */
    for ( QStringList::Iterator it = list. begin ( ); it != list. end ( ); ++it ) {
        QString name;
        QPixmap icon;
        TaskbarNamedAppletInterface *iface = 0;
        owarn << "Load applet: " << (*it) << "" << oendl;
        QLibrary *lib = new QLibrary ( path + "/" + *it );
-        lib-> queryInterface ( IID_TaskbarNamedApplet, (QUnknownInterface**) &iface );
+        QRESULT retVal = QS_OK;
+        if ((retVal = lib-> queryInterface ( IID_TaskbarNamedApplet, (QUnknownInterface**)(&iface) )) != QS_OK)
+            owarn << "<0>" << oendl;
        owarn << "<1>" << oendl;
        if ( iface ) {
            owarn << "<2>" << oendl;
            QString lang = getenv( "LANG" );
            QTranslator *trans = new QTranslator ( qApp );
            QString type = (*it). left ((*it). find ("."));
            QString tfn = QPEApplication::qpeDir ( ) + "i18n/" + lang + "/" + type + ".qm";
            if ( trans-> load ( tfn ))
                qApp-> installTranslator ( trans );
            else
                delete trans;
            name = iface-> name ( );
            icon = iface-> icon ( );
            iface-> release ( );
        }
        owarn << "<3>" << oendl;
        if ( !iface ) {
            owarn << "<4>" << oendl;
-            lib-> queryInterface ( IID_TaskbarApplet, (QUnknownInterface**) &iface );
+            if ((retVal = lib-> queryInterface ( IID_TaskbarApplet, (QUnknownInterface**)(&iface))) != QS_OK)
+                owarn << "<5>" << oendl;
            if ( iface ) {
-                owarn << "<5>" << oendl;
+                owarn << "<6>" << oendl;
                name = (*it). mid ( 3 );
                owarn << "Found applet: " << name << "" << oendl;
 #ifdef Q_OS_MACX
                int sep = name. find( ".dylib" );
 #else
                int sep = name. find( ".so" );
 #endif /* Q_OS_MACX */
                if ( sep > 0 )
                    name. truncate ( sep );
                sep = name. find ( "applet" );
                if ( sep == (int) name.length ( ) - 6 )
                    name. truncate ( sep );
                name[0] = name[0]. upper ( );
                iface-> release ( );
            }
        }
-        owarn << "<6>" << oendl;
+        owarn << "<7>" << oendl;
        if ( iface ) {
-            owarn << "<7>" << oendl;
+            owarn << "<8>" << oendl;
            QCheckListItem *item;
            item = new QCheckListItem ( m_list, name, QCheckListItem::CheckBox );
            if ( !icon. isNull ( ))
                item-> setPixmap ( 0, icon );
            item-> setOn ( exclude. find ( *it ) == exclude. end ( ));
            m_applets [*it] = item;
        }
        lib-> unload ( );
        delete lib;
    }
 }
 void TaskbarSettings::appletChanged()
 {
    m_applets_changed = true;
 }
 void TaskbarSettings::accept ( )
 {
    Config cfg ( "Taskbar" );
    cfg. setGroup ( "Applets" );
    if ( m_applets_changed ) {
        QStringList exclude;
        QMap <QString, QCheckListItem *>::Iterator it;
        for ( it = m_applets. begin ( ); it != m_applets. end ( ); ++it ) {
            if ( !(*it)-> isOn ( ))
                exclude << it. key ( );
        }
        cfg. writeEntry ( "ExcludeApplets", exclude, ',' );
    }
    cfg. writeEntry ( "SafeMode", false );
    cfg. write ( );
    if ( m_applets_changed ) {
        QCopEnvelope e ( "QPE/TaskBar", "reloadApplets()" );
        m_applets_changed = false;
    }
 }
diff --git a/libopie2/opiecore/oglobal.cpp b/libopie2/opiecore/oglobal.cpp
index 706ac6c..b7d59fc 100644
--- a/libopie2/opiecore/oglobal.cpp
+++ b/libopie2/opiecore/oglobal.cpp
@@ -1,422 +1,422 @@
 /*
                             This file is part of the Opie Project
                             Copyright (C) 2003 Michael 'Mickey' Lauer <mickey@Vanille.de>
              =.             Copyright (C) 2004 Holger 'zecke' Freyther <zecke@handhelds.org>
            .=l.
           .>+-=
 _;:,     .>    :=|.         This program is free software; you can
 .> <`_,   >  .   <=          redistribute it and/or  modify it under
 :`=1 )Y*s>-.--   :           the terms of the GNU Library General Public
 .="- .-=="i,     .._         License as published by the Free Software
 - .   .-<_>     .<>         Foundation; either version 2 of the License,
     ._= =}       :          or (at your option) any later version.
    .%`+i>       _;_.
    .i_,=:_.      -<s.       This program 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 <opie2/oglobal.h>
 #include <qtextstream.h>
 #include <qdir.h>
 #include <qpe/mimetype.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/storage.h>
 #include <unistd.h>
 #include <sys/types.h>
 using namespace Opie::Core;
 static const char Base64EncMap[64] =
 {
  0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
  0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, 0x50,
  0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
  0x59, 0x5A, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
  0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E,
  0x6F, 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76,
  0x77, 0x78, 0x79, 0x7A, 0x30, 0x31, 0x32, 0x33,
  0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x2B, 0x2F
 };
 static char Base64DecMap[128] =
 {
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x00, 0x3E, 0x00, 0x00, 0x00, 0x3F,
  0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3A, 0x3B,
  0x3C, 0x3D, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
  0x07, 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E,
  0x0F, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
  0x17, 0x18, 0x19, 0x00, 0x00, 0x00, 0x00, 0x00,
  0x00, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, 0x20,
  0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28,
  0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30,
  0x31, 0x32, 0x33, 0x00, 0x00, 0x00, 0x00, 0x00
 };
 OConfig* OGlobal::_config = 0;
 OConfig* OGlobal::_qpe_config = 0;
 void OGlobal::clean_up()
 {
    qDebug( "Oglobal clean up" );
    delete OGlobal::_config;
    delete OGlobal::_qpe_config;
    OGlobal::_config = 0;
    OGlobal::_qpe_config = 0;
 }
 OConfig* OGlobal::config()
 {
    if ( !OGlobal::_config )
    {
        // odebug classes are reading config, so can't use them here!
        qAddPostRoutine( OGlobal::clean_up );
        qDebug( "OGlobal::creating global configuration instance." );
        OGlobal::_config = new OConfig( "global" );
    }
    return OGlobal::_config;
 }
 /**
 * Return the internal builtin Global::Command object
 *
 */
 Global::Command* OGlobal::builtinCommands() {
    return builtin;
 }
 /**
 * Return the internal builtin QGuardedPtr<QWidget> object
 */
 QGuardedPtr<QWidget>* OGlobal::builtinRunning() {
    return running;
 }
 /**
 * \brief generate a new UUID as QString
 * Return a new UUID as QString. UUID are global unique
 *
 *
 * @return the UUID or QString::null
 */
 QString OGlobal::generateUuid() {
    QFile file( "/proc/sys/kernel/random/uuid" );
    if (!file.open(IO_ReadOnly ) )
        return QString::null;
    QTextStream stream(&file);
    return "{" + stream.read().stripWhiteSpace() + "}";
 }
 /**
 * \brief Encode a QByteArray in base64
 *
 * An Implementation of the RF1521 base64 encoding.
 *
 * The boolean argument determines if the encoded data is
 * going to be restricted to 76 characters or less per line
 * as specified by RFC 2045.  If @p insertLFs is true, then
 * there will be 76 characters or less per line.
 *
 * If you use this to create a QCString remember that it is null terminated!
 * \code
 * QByteArray ar = OGlobal::encodeBase64(&array);
 * QCString str(ar.data(),ar.size()+1); // the NUL at the end
 *
 * \endcode
 *
 * @param in The QByteArray to encode
 * @param insertLFs Limit number of characters per line
 * @return The argument as base64 encoded or QByteArray() if in.isEmpty()
 * @see QByteArray
 * @see QArray
 * @see QMemArray
 * @see QCString
 */
 /*
 * LGPL by Rik Hemsely of the KDE Project. taken from kmdcodec.cpp
 */
 QByteArray OGlobal::encodeBase64(const QByteArray& in, bool insertLFs ) {
    if ( in.isEmpty() )
        return QByteArray();
    unsigned int sidx = 0;
    unsigned int didx = 0;
    const char* data = in.data();
    const unsigned int len = in.size();
    unsigned int out_len = ((len+2)/3)*4;
    // Deal with the 76 characters or less per
    // line limit specified in RFC 2045 on a
    // pre request basis.
    insertLFs = (insertLFs && out_len > 76);
    if ( insertLFs )
      out_len += ((out_len-1)/76);
    int count = 0;
    QByteArray out( out_len );
    // 3-byte to 4-byte conversion + 0-63 to ascii printable conversion
    if ( len > 1 )
    {
        while (sidx < len-2)
        {
            if ( insertLFs )
            {
                if ( count && (count%76) == 0 )
                    out[didx++] = '\n';
                count += 4;
            }
            out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
            out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
                                       (data[sidx] << 4) & 077];
            out[didx++] = Base64EncMap[(data[sidx+2] >> 6) & 003 |
                                       (data[sidx+1] << 2) & 077];
            out[didx++] = Base64EncMap[data[sidx+2] & 077];
            sidx += 3;
        }
    }
    if (sidx < len)
    {
        if ( insertLFs && (count > 0) && (count%76) == 0 )
           out[didx++] = '\n';
        out[didx++] = Base64EncMap[(data[sidx] >> 2) & 077];
        if (sidx < len-1)
        {
            out[didx++] = Base64EncMap[(data[sidx+1] >> 4) & 017 |
                                       (data[sidx] << 4) & 077];
            out[didx++] = Base64EncMap[(data[sidx+1] << 2) & 077];
        }
        else
        {
            out[didx++] = Base64EncMap[(data[sidx] << 4) & 077];
        }
    }
    // Add padding
    while (didx < out.size())
    {
        out[didx] = '=';
        didx++;
    }
    return out;
 }
 /**
 * Decodes the given data that was encoded with the base64
 * algorithm.
 *
 *
 * @param in   the encoded data to be decoded.
 * @return the decoded QByteArray or QByteArray() in case of failure
 * @see OGlobal::encodeBase64
 */
 QByteArray OGlobal::decodeBase64( const QByteArray& in) {
    if ( in.isEmpty() )
        return QByteArray();
    QByteArray out;
    unsigned int count = 0;
    unsigned int len = in.size(), tail = len;
    const char* data = in.data();
    // Deal with possible *nix "BEGIN" marker!!
    while ( count < len && (data[count] == '\n' || data[count] == '\r' ||
            data[count] == '\t' || data[count] == ' ') )
        count++;
    if ( strncasecmp(data+count, "begin", 5) == 0 )
    {
        count += 5;
        while ( count < len && data[count] != '\n' && data[count] != '\r' )
            count++;
        while ( count < len && (data[count] == '\n' || data[count] == '\r') )
            count ++;
        data += count;
        tail = (len -= count);
    }
    // Find the tail end of the actual encoded data even if
    // there is/are trailing CR and/or LF.
    while ( data[tail-1] == '=' || data[tail-1] == '\n' ||
            data[tail-1] == '\r' )
        if ( data[--tail] != '=' ) len = tail;
    unsigned int outIdx = 0;
    out.resize( (count=len) );
    for (unsigned int idx = 0; idx < count; idx++)
    {
        // Adhere to RFC 2045 and ignore characters
        // that are not part of the encoding table.
        unsigned char ch = data[idx];
        if ( (ch > 47 && ch < 58) || (ch > 64 && ch < 91 ) ||
             (ch > 96 && ch < 123)|| ch == '+' || ch == '/' || ch == '=')
        {
            out[outIdx++] = Base64DecMap[ch];
        }
        else
        {
            len--;
            tail--;
        }
    }
    // kdDebug() << "Tail size = " << tail << ", Length size = " << len << endl;
    // 4-byte to 3-byte conversion
    len = (tail>(len/4)) ? tail-(len/4) : 0;
    unsigned int sidx = 0, didx = 0;
    if ( len > 1 )
    {
      while (didx < len-2)
      {
          out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
          out[didx+1] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
          out[didx+2] = (((out[sidx+2] << 6) & 255) | (out[sidx+3] & 077));
          sidx += 4;
          didx += 3;
      }
    }
    if (didx < len)
        out[didx] = (((out[sidx] << 2) & 255) | ((out[sidx+1] >> 4) & 003));
    if (++didx < len )
        out[didx] = (((out[sidx+1] << 4) & 255) | ((out[sidx+2] >> 2) & 017));
    // Resize the output buffer
    if ( len == 0 || len < out.size() )
      out.resize(len);
    return out;
 }
 bool OGlobal::isAppLnkFileName( const QString& str )
 {
    if (str.isEmpty()||str.at(str.length()-1)==QDir::separator()) return false;
    return str.startsWith(MimeType::appsFolderName()+QDir::separator());
 }
 /* ToDo:
 * This fun should check the document-path value for the mounted media
 * which has to be implemented later. this moment we just check for a
 * mounted media name.
 */
 bool OGlobal::isDocumentFileName( const QString& file )
 {
    if (file.isEmpty()||file.at(file.length()-1)==QDir::separator()) return false;
    if (file.startsWith(QPEApplication::documentDir()+QDir::separator())) return true;
    StorageInfo si;
    QList< FileSystem > fl =  si.fileSystems();
    FileSystem*fs;
    for (fs = fl.first();fs!=0;fs=fl.next()) {
        if (fs->isRemovable()&&file.startsWith(fs->name()+QDir::separator()))
            return true;
    }
-    if (file.startsWith(homeDirPath())+"/Documents/") return true;
+    if (file.startsWith(homeDirPath()+"/Documents/")) return true;
    return false;
 }
 QString OGlobal::tempDirPath()
 {
    static QString defstring="/tmp";
    char * tmpp = 0;
    if ( (tmpp=getenv("TEMP"))) {
        return tmpp;
    }
    return defstring;
 }
 QString OGlobal::homeDirPath()
 {
    char * tmpp = getenv("HOME");
    return (tmpp?tmpp:"/");
 }
 bool OGlobal::weekStartsOnMonday()
 {
    OConfig*conf=OGlobal::qpe_config();
    if (!conf)return false;
    conf->setGroup("Time");
    return conf->readBoolEntry("MONDAY",true);
 }
 void OGlobal::setWeekStartsOnMonday( bool what)
 {
    OConfig*conf=OGlobal::qpe_config();
    if (!conf)return;
    conf->setGroup("Time");
    return conf->writeEntry("MONDAY",what);
 }
 bool OGlobal::useAMPM()
 {
    OConfig*conf=OGlobal::qpe_config();
    if (!conf)return false;
    conf->setGroup("Time");
    return conf->readBoolEntry("AMPM",false);
 }
 void OGlobal::setUseAMPM( bool what)
 {
    OConfig*conf=OGlobal::qpe_config();
    if (!conf)return;
    conf->setGroup("Time");
    return conf->writeEntry("AMPM",what);
 }
 OConfig* OGlobal::qpe_config()
 {
    if ( !OGlobal::_qpe_config ) {
        OGlobal::_qpe_config = new OConfig( "qpe" );
    }
    return OGlobal::_qpe_config;
 }
 bool OGlobal::truncateFile( QFile &f, off_t size )
 {
    /* or should we let enlarge Files? then remove this
       f.size()< part! - Alwin
    */
    if (!f.exists()||f.size()<(unsigned)size) return false;
    bool closeit=false;
    if (!f.isOpen()) {
        closeit=true;
        f.open(IO_Raw | IO_ReadWrite | IO_Append);
    }
    if (!f.isOpen()) { return false; }
    int r = ftruncate(f.handle(),size);
    if (closeit) f.close();
    return r==0;
 }
diff --git a/libopie2/opiecore/oprocess.cpp b/libopie2/opiecore/oprocess.cpp
index b3f9724..56f9883 100644
--- a/libopie2/opiecore/oprocess.cpp
+++ b/libopie2/opiecore/oprocess.cpp
@@ -547,405 +547,405 @@ bool OProcess::closeStderr()
    if ( communication & Stderr )
    {
        communication = static_cast<Communication>( communication & ~Stderr );
        delete errnot;
        errnot = 0;
        close( err[ 0 ] );
        rv = true;
    }
    else
        rv = false;
    return rv;
 }
 void OProcess::slotChildOutput( int fdno )
 {
    if ( !childOutput( fdno ) )
        closeStdout();
 }
 void OProcess::slotChildError( int fdno )
 {
    if ( !childError( fdno ) )
        closeStderr();
 }
 void OProcess::slotSendData( int )
 {
    if ( input_sent == input_total )
    {
        innot->setEnabled( false );
        input_data = 0;
        emit wroteStdin( this );
    }
    else
        input_sent += ::write( in[ 1 ], input_data + input_sent, input_total - input_sent );
 }
 void OProcess::processHasExited( int state )
 {
    if ( runs )
    {
        runs = false;
        status = state;
        commClose(); // cleanup communication sockets
        // also emit a signal if the process was run Blocking
        if ( DontCare != run_mode )
        {
            emit processExited( this );
        }
    }
 }
 int OProcess::childOutput( int fdno )
 {
    if ( communication & NoRead )
    {
        int len = -1;
        emit receivedStdout( fdno, len );
        errno = 0; // Make sure errno doesn't read "EAGAIN"
        return len;
    }
    else
    {
        char buffer[ 1024 ];
        int len;
        len = ::read( fdno, buffer, 1024 );
        if ( 0 < len )
        {
            emit receivedStdout( this, buffer, len );
        }
        return len;
    }
 }
 int OProcess::childError( int fdno )
 {
    char buffer[ 1024 ];
    int len;
    len = ::read( fdno, buffer, 1024 );
    if ( 0 < len )
        emit receivedStderr( this, buffer, len );
    return len;
 }
 int OProcess::setupCommunication( Communication comm )
 {
    int ok;
    communication = comm;
    ok = 1;
    if ( comm & Stdin )
        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, in ) >= 0;
    if ( comm & Stdout )
        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, out ) >= 0;
    if ( comm & Stderr )
        ok &= socketpair( AF_UNIX, SOCK_STREAM, 0, err ) >= 0;
    return ok;
 }
 int OProcess::commSetupDoneP()
 {
    int ok = 1;
    if ( communication != NoCommunication )
    {
        if ( communication & Stdin )
            close( in[ 0 ] );
        if ( communication & Stdout )
            close( out[ 1 ] );
        if ( communication & Stderr )
            close( err[ 1 ] );
        // Don't create socket notifiers and set the sockets non-blocking if
        // blocking is requested.
        if ( run_mode == Block )
            return ok;
        if ( communication & Stdin )
        {
            //        ok &= (-1 != fcntl(in[1], F_SETFL, O_NONBLOCK));
            innot = new QSocketNotifier( in[ 1 ], QSocketNotifier::Write, this );
            CHECK_PTR( innot );
            innot->setEnabled( false ); // will be enabled when data has to be sent
            QObject::connect( innot, SIGNAL( activated(int) ),
                              this, SLOT( slotSendData(int) ) );
        }
        if ( communication & Stdout )
        {
            //        ok &= (-1 != fcntl(out[0], F_SETFL, O_NONBLOCK));
            outnot = new QSocketNotifier( out[ 0 ], QSocketNotifier::Read, this );
            CHECK_PTR( outnot );
            QObject::connect( outnot, SIGNAL( activated(int) ),
                              this, SLOT( slotChildOutput(int) ) );
            if ( communication & NoRead )
                suspend();
        }
        if ( communication & Stderr )
        {
            //        ok &= (-1 != fcntl(err[0], F_SETFL, O_NONBLOCK));
            errnot = new QSocketNotifier( err[ 0 ], QSocketNotifier::Read, this );
            CHECK_PTR( errnot );
            QObject::connect( errnot, SIGNAL( activated(int) ),
                              this, SLOT( slotChildError(int) ) );
        }
    }
    return ok;
 }
 int OProcess::commSetupDoneC()
 {
    int ok = 1;
    struct linger so;
    memset( &so, 0, sizeof( so ) );
    if ( communication & Stdin )
        close( in[ 1 ] );
    if ( communication & Stdout )
        close( out[ 0 ] );
    if ( communication & Stderr )
        close( err[ 0 ] );
    if ( communication & Stdin )
        ok &= dup2( in[ 0 ], STDIN_FILENO ) != -1;
    else
    {
        int null_fd = open( "/dev/null", O_RDONLY );
        ok &= dup2( null_fd, STDIN_FILENO ) != -1;
        close( null_fd );
    }
    if ( communication & Stdout )
    {
        ok &= dup2( out[ 1 ], STDOUT_FILENO ) != -1;
        ok &= !setsockopt( out[ 1 ], SOL_SOCKET, SO_LINGER, ( char* ) & so, sizeof( so ) );
    }
    else
    {
        int null_fd = open( "/dev/null", O_WRONLY );
        ok &= dup2( null_fd, STDOUT_FILENO ) != -1;
        close( null_fd );
    }
    if ( communication & Stderr )
    {
        ok &= dup2( err[ 1 ], STDERR_FILENO ) != -1;
        ok &= !setsockopt( err[ 1 ], SOL_SOCKET, SO_LINGER, reinterpret_cast<char *>( &so ), sizeof( so ) );
    }
    else
    {
        int null_fd = open( "/dev/null", O_WRONLY );
        ok &= dup2( null_fd, STDERR_FILENO ) != -1;
        close( null_fd );
    }
    return ok;
 }
 void OProcess::commClose()
 {
    if ( NoCommunication != communication )
    {
        bool b_in = ( communication & Stdin );
        bool b_out = ( communication & Stdout );
        bool b_err = ( communication & Stderr );
        if ( b_in )
            delete innot;
        if ( b_out || b_err )
        {
            // If both channels are being read we need to make sure that one socket buffer
            // doesn't fill up whilst we are waiting for data on the other (causing a deadlock).
            // Hence we need to use select.
            // Once one or other of the channels has reached EOF (or given an error) go back
            // to the usual mechanism.
            int fds_ready = 1;
            fd_set rfds;
            int max_fd = 0;
            if ( b_out )
            {
                fcntl( out[ 0 ], F_SETFL, O_NONBLOCK );
                if ( out[ 0 ] > max_fd )
                    max_fd = out[ 0 ];
                delete outnot;
                outnot = 0;
            }
            if ( b_err )
            {
                fcntl( err[ 0 ], F_SETFL, O_NONBLOCK );
                if ( err[ 0 ] > max_fd )
                    max_fd = err[ 0 ];
                delete errnot;
                errnot = 0;
            }
            while ( b_out || b_err )
            {
                // * If the process is still running we block until we
                // receive data. (p_timeout = 0, no timeout)
                // * If the process has already exited, we only check
                // the available data, we don't wait for more.
                // (p_timeout = &timeout, timeout immediately)
                struct timeval timeout;
                timeout.tv_sec = 0;
                timeout.tv_usec = 0;
                struct timeval *p_timeout = runs ? 0 : &timeout;
                FD_ZERO( &rfds );
                if ( b_out )
                    FD_SET( out[ 0 ], &rfds );
                if ( b_err )
                    FD_SET( err[ 0 ], &rfds );
                fds_ready = select( max_fd + 1, &rfds, 0, 0, p_timeout );
                if ( fds_ready <= 0 )
                    break;
                if ( b_out && FD_ISSET( out[ 0 ], &rfds ) )
                {
                    int ret = 1;
                    while ( ret > 0 )
                        ret = childOutput( out[ 0 ] );
                    if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 )
                        b_out = false;
                }
                if ( b_err && FD_ISSET( err[ 0 ], &rfds ) )
                {
                    int ret = 1;
                    while ( ret > 0 )
                        ret = childError( err[ 0 ] );
                    if ( ( ret == -1 && errno != EAGAIN ) || ret == 0 )
                        b_err = false;
                }
            }
        }
        if ( b_in )
        {
            communication = ( Communication ) ( communication & ~Stdin );
            close( in[ 1 ] );
        }
        if ( b_out )
        {
            communication = ( Communication ) ( communication & ~Stdout );
            close( out[ 0 ] );
        }
        if ( b_err )
        {
            communication = ( Communication ) ( communication & ~Stderr );
            close( err[ 0 ] );
        }
    }
 }
 void OProcess::setUseShell( bool useShell, const char *shell )
 {
    if ( !d )
        d = new OProcessPrivate;
    d->useShell = useShell;
    d->shell = shell;
    if ( d->shell.isEmpty() )
        d->shell = searchShell();
 }
 QString OProcess::quote( const QString &arg )
 {
    QString res = arg;
    res.replace( QRegExp( QString::fromLatin1( "\'" ) ),
                 QString::fromLatin1( "'\"'\"'" ) );
    res.prepend( '\'' );
    res.append( '\'' );
    return res;
 }
 QCString OProcess::searchShell()
 {
    QCString tmpShell = QCString( getenv( "SHELL" ) ).stripWhiteSpace();
    if ( !isExecutable( tmpShell ) )
    {
        tmpShell = "/bin/sh";
    }
    return tmpShell;
 }
 bool OProcess::isExecutable( const QCString &filename )
 {
    struct stat fileinfo;
    if ( filename.isEmpty() )
        return false;
    // CC: we've got a valid filename, now let's see whether we can execute that file
    if ( -1 == stat( filename.data(), &fileinfo ) )
        return false;
    // CC: return false if the file does not exist
    // CC: anyway, we cannot execute directories, block/character devices, fifos or sockets
    if ( ( S_ISDIR( fileinfo.st_mode ) ) ||
            ( S_ISCHR( fileinfo.st_mode ) ) ||
            ( S_ISBLK( fileinfo.st_mode ) ) ||
 #ifdef S_ISSOCK
            // CC: SYSVR4 systems don't have that macro
            ( S_ISSOCK( fileinfo.st_mode ) ) ||
 #endif
            ( S_ISFIFO( fileinfo.st_mode ) ) ||
            ( S_ISDIR( fileinfo.st_mode ) ) )
    {
        return false;
    }
    // CC: now check for permission to execute the file
    if ( access( filename.data(), X_OK ) != 0 )
        return false;
    // CC: we've passed all the tests...
    return true;
 }
 int OProcess::processPID( const QString& process )
 {
    QString line;
    QDir d = QDir( "/proc" );
    QStringList dirs = d.entryList( QDir::Dirs );
    QStringList::Iterator it;
    for ( it = dirs.begin(); it != dirs.end(); ++it )
    {
        //qDebug( "next entry: %s", (const char*) *it );
        QFile file( "/proc/"+*it+"/cmdline" );
-        file.open( IO_ReadOnly );
+        if ( !file.open( IO_ReadOnly ) ) continue;
        if ( !file.isOpen() ) continue;
        QTextStream t( &file );
        line = t.readLine();
        //qDebug( "cmdline = %s", (const char*) line );
        if ( line.contains( process ) ) break; //FIXME: That may find also other process, if the name is not long enough ;)
    }
    if ( line.contains( process ) )
    {
        //qDebug( "found process id #%d", (*it).toInt() );
        return (*it).toInt();
    }
    else
    {
        //qDebug( "process '%s' not found", (const char*) process );
        return 0;
    }
 }
 }
 }
diff --git a/library/global.cpp b/library/global.cpp
index f7a0767..7bdd0b1 100644
--- a/library/global.cpp
+++ b/library/global.cpp
@@ -1,635 +1,634 @@
 /**********************************************************************
 ** Copyright (C) 2000-2002 Trolltech AS.  All rights reserved.
 **
 ** This file is part of the 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.
 **
 **********************************************************************/
 #define QTOPIA_INTERNAL_LANGLIST
 #include <qpe/qpedebug.h>
 #include <qpe/global.h>
 #include <qpe/qdawg.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/resource.h>
 #include <qpe/storage.h>
 #include <qpe/applnk.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/config.h>
 #include <qlabel.h>
 #include <qtimer.h>
 #include <qmap.h>
 #include <qdict.h>
 #include <qdir.h>
 #include <qmessagebox.h>
 #include <qregexp.h>
 #include <stdlib.h>
 #include <sys/stat.h>
 #include <sys/wait.h>
 #include <sys/types.h>
 #include <fcntl.h>
 #include <unistd.h>
 #include <errno.h>
 #include <qwindowsystem_qws.h> // for qwsServer
 #include <qdatetime.h>
 //#include "quickexec_p.h"
 class Emitter : public QObject {
    Q_OBJECT
 public:
    Emitter( QWidget* receiver, const QString& document )
    {
    connect(this, SIGNAL(setDocument(const QString&)),
        receiver, SLOT(setDocument(const QString&)));
    emit setDocument(document);
    disconnect(this, SIGNAL(setDocument(const QString&)),
           receiver, SLOT(setDocument(const QString&)));
    }
 signals:
    void setDocument(const QString&);
 };
 class StartingAppList : public QObject {
    Q_OBJECT
 public:
    static void add( const QString& name );
    static bool isStarting( const QString name );
 private slots:
    void handleNewChannel( const QString &);
 private:
    StartingAppList( QObject *parent=0, const char* name=0 ) ;
    QDict<QTime> dict;
    static StartingAppList *appl;
 };
 StartingAppList* StartingAppList::appl = 0;
 StartingAppList::StartingAppList( QObject *parent, const char* name )
    :QObject( parent, name )
 {
 #if QT_VERSION >= 232 && defined(QWS)
    connect( qwsServer, SIGNAL( newChannel(const QString&)),
         this, SLOT( handleNewChannel(const QString&)) );
 #endif
    dict.setAutoDelete( TRUE );
 }
 void StartingAppList::add( const QString& name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
    if ( !appl )
    appl = new StartingAppList;
    QTime *t = new QTime;
    t->start();
    appl->dict.insert( "QPE/Application/" + name, t );
 #endif
 }
 bool StartingAppList::isStarting( const QString name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
    if ( appl ) {
    QTime *t  = appl->dict.find( "QPE/Application/" + name );
    if ( !t )
        return FALSE;
    if ( t->elapsed() > 10000 ) {
        // timeout in case of crash or something
        appl->dict.remove( "QPE/Application/" + name );
        return FALSE;
    }
    return TRUE;
    }
 #endif
    return FALSE;
 }
 void StartingAppList::handleNewChannel( const QString & name )
 {
 #if QT_VERSION >= 232  && !defined(QT_NO_COP)
    dict.remove( name );
 #endif
 }
 static bool docDirCreated = FALSE;
 static QDawg* fixed_dawg = 0;
 static QDict<QDawg> *named_dawg = 0;
 static QString qpeDir()
 {
    QString dir = getenv("OPIEDIR");
    if ( dir.isEmpty() ) dir = "..";
    return dir;
 }
 static QString dictDir()
 {
    return qpeDir() + "/etc/dict";
 }
 /*!
  \class Global global.h
  \brief The Global class provides application-wide global functions.
  The Global functions are grouped as follows:
  \tableofcontents
  \section1 User Interface
  The statusMessage() function provides short-duration messages to the
  user. The showInputMethod() function shows the current input method,
  and hideInputMethod() hides the input method.
  \section1 Document related
  The findDocuments() function creates a set of \link doclnk.html
  DocLnk\endlink objects in a particular folder.
  \section1 Filesystem related
  Global provides an applicationFileName() function that returns the
  full path of an application-specific file.
  The execute() function runs an application.
  \section1 Word list related
  A list of words relevant to the current locale is maintained by the
  system. The list is held in a \link qdawg.html DAWG\endlink
  (implemented by the QDawg class). This list is used, for example, by
  the pickboard input method.
  The global QDawg is returned by fixedDawg(); this cannot be updated.
  An updatable copy of the global QDawg is returned by addedDawg().
  Applications may have their own word lists stored in \l{QDawg}s
  which are returned by dawg(). Use addWords() to add words to the
  updateable copy of the global QDawg or to named application
  \l{QDawg}s.
  \section1 Quoting
  The shellQuote() function quotes a string suitable for passing to a
  shell. The stringQuote() function backslash escapes '\' and '"'
  characters.
  \section1 Hardware
  The implementation of the writeHWClock() function depends on the AlarmServer
  implementation. If the AlarmServer is using atd the clock will be synced to
  hardware. If opie-alarm is used the hardware clock will be synced before
  suspending the device. opie-alarm is used by iPAQ and Zaurii implementation
  \ingroup qtopiaemb
 */
 /*!
  \internal
 */
 Global::Global()
 {
 }
 /*!
  Returns the unchangeable QDawg that contains general
  words for the current locale.
  \sa addedDawg()
 */
 const QDawg& Global::fixedDawg()
 {
    if ( !fixed_dawg ) {
-    if ( !docDirCreated )
+        if ( !docDirCreated )
-        createDocDir();
+            createDocDir();
-    fixed_dawg = new QDawg;
+        fixed_dawg = new QDawg;
-    QString dawgfilename = dictDir() + "/dawg";
+        QString dawgfilename = dictDir() + "/dawg";
-    QString words_lang;
+        QString words_lang;
-    QStringList langs = Global::languageList();
+        QStringList langs = Global::languageList();
-    for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
+        for (QStringList::ConstIterator it = langs.begin(); it!=langs.end(); ++it) {
-        QString lang = *it;
+            QString lang = *it;
-        words_lang = dictDir() + "/words." + lang;
+            words_lang = dictDir() + "/words." + lang;
-        QString dawgfilename_lang = dawgfilename + "." + lang;
+            QString dawgfilename_lang = dawgfilename + "." + lang;
-        if ( QFile::exists(dawgfilename_lang) ||
+            if ( QFile::exists(dawgfilename_lang) ||
-         QFile::exists(words_lang) ) {
+                 QFile::exists(words_lang) ) {
-        dawgfilename = dawgfilename_lang;
+                dawgfilename = dawgfilename_lang;
-        break;
+                break;
-        }
+            }
-    }
-    QFile dawgfile(dawgfilename);
-    if ( !dawgfile.exists() ) {
-        QString fn = dictDir() + "/words";
-        if ( QFile::exists(words_lang) )
-        fn = words_lang;
-        QFile in(fn);
-        if ( in.open(IO_ReadOnly) ) {
-        fixed_dawg->createFromWords(&in);
-        dawgfile.open(IO_WriteOnly);
-        fixed_dawg->write(&dawgfile);
-        dawgfile.close();
        }
-    } else {
+        QFile dawgfile(dawgfilename);
-        fixed_dawg->readFile(dawgfilename);
-    }
+        if ( !dawgfile.exists() ) {
+            QString fn = dictDir() + "/words";
+            if ( QFile::exists(words_lang) )
+                fn = words_lang;
+            QFile in(fn);
+            if ( in.open(IO_ReadOnly) ) {
+                fixed_dawg->createFromWords(&in);
+                if (dawgfile.open(IO_WriteOnly))
+                    fixed_dawg->write(&dawgfile);
+                dawgfile.close();
+            }
+        } else
+            fixed_dawg->readFile(dawgfilename);
    }
    return *fixed_dawg;
 }
 /*!
  Returns the changeable QDawg that contains general
  words for the current locale.
  \sa fixedDawg()
 */
 const QDawg& Global::addedDawg()
 {
    return dawg("local");
 }
 /*!
  Returns the QDawg with the given \a name.
  This is an application-specific word list.
  \a name should not contain "/".
 */
 const QDawg& Global::dawg(const QString& name)
 {
    createDocDir();
    if ( !named_dawg )
    named_dawg = new QDict<QDawg>;
    QDawg* r = named_dawg->find(name);
    if ( !r ) {
    r = new QDawg;
    named_dawg->insert(name,r);
    QString dawgfilename = applicationFileName("Dictionary", name ) + ".dawg";
    QFile dawgfile(dawgfilename);
    if ( dawgfile.open(IO_ReadOnly) )
        r->readFile(dawgfilename);
    }
    return *r;
 }
 /*!
  \overload
  Adds \a wordlist to the addedDawg().
  Note that the addition of words persists between program executions
  (they are saved in the dictionary files), so you should confirm the
  words with the user before adding them.
 */
 void Global::addWords(const QStringList& wordlist)
 {
    addWords("local",wordlist);
 }
 /*!
  \overload
  Adds \a wordlist to the addedDawg().
  Note that the addition of words persists between program executions
  (they are saved in the dictionary files), so you should confirm the
  words with the user before adding them.
 */
 void Global::addWords(const QString& dictname, const QStringList& wordlist)
 {
    QDawg& d = (QDawg&)dawg(dictname);
    QStringList all = d.allWords() + wordlist;
    d.createFromWords(all);
    QString dawgfilename = applicationFileName("Dictionary", dictname) + ".dawg";
    QFile dawgfile(dawgfilename);
    if ( dawgfile.open(IO_WriteOnly) ) {
    d.write(&dawgfile);
    dawgfile.close();
    }
    // #### Re-read the dawg here if we use mmap().
    // #### Signal other processes to re-read.
 }
 /*!
  Returns the full path for the application called \a appname, with the
  given \a filename. Returns QString::null if there was a problem creating
  the directory tree for \a appname.
  If \a filename contains "/", it is the caller's responsibility to
  ensure that those directories exist.
 */
 QString Global::applicationFileName(const QString& appname, const QString& filename)
 {
    QDir d;
    QString r = getenv("HOME");
    r += "/Applications/";
    if ( !QFile::exists( r ) )
    if ( d.mkdir(r) == false )
        return QString::null;
    r += appname;
    if ( !QFile::exists( r ) )
    if ( d.mkdir(r) == false )
        return QString::null;
    r += "/"; r += filename;
    return r;
 }
 /*!
  \internal
 */
 void Global::createDocDir()
 {
    if ( !docDirCreated ) {
    docDirCreated = TRUE;
    mkdir( QPEApplication::documentDir().latin1(), 0755 );
    }
 }
 /*!
  Displays a status \a message to the user. This usually appears
  in the taskbar for a short amount of time, then disappears.
 */
 void Global::statusMessage(const QString& message)
 {
 #if !defined(QT_NO_COP)
    QCopEnvelope e( "QPE/TaskBar", "message(QString)" );
    e << message;
 #endif
 }
 /*!
  \internal
 */
 void Global::applyStyle()
 {
 #if !defined(QT_NO_COP)
    QCopChannel::send( "QPE/System", "applyStyle()" );
 #else
    ((QPEApplication *)qApp)->applyStyle(); // apply without needing QCop for floppy version
 #endif
 }
 /*!
  \internal
 */
 QWidget *Global::shutdown( bool )
 {
 #if !defined(QT_NO_COP)
    QCopChannel::send( "QPE/System", "shutdown()" );
 #endif
    return 0;
 }
 /*!
  \internal
 */
 QWidget *Global::restart( bool )
 {
 #if !defined(QT_NO_COP)
    QCopChannel::send( "QPE/System", "restart()" );
 #endif
    return 0;
 }
 /*!
  Explicitly show the current input method.
  Input methods are indicated in the taskbar by a small icon. If the
  input method is activated (shown) then it takes up some proportion
  of the bottom of the screen, to allow the user to interact (input
  characters) with it.
  \sa hideInputMethod()
 */
 void Global::showInputMethod()
 {
 #if !defined(QT_NO_COP)
    QCopChannel::send( "QPE/TaskBar", "showInputMethod()" );
 #endif
 }
 /*!
  Explicitly hide the current input method.
  The current input method is still indicated in the taskbar, but no
  longer takes up screen space, and can no longer be interacted with.
  \sa showInputMethod()
 */
 void Global::hideInputMethod()
 {
 #if !defined(QT_NO_COP)
    QCopChannel::send( "QPE/TaskBar", "hideInputMethod()" );
 #endif
 }
 /*!
  \internal
 */
 bool Global::isBuiltinCommand( const QString &name )
 {
    if(!builtin)
    return FALSE; // yes, it can happen
    for (int i = 0; builtin[i].file; i++) {
    if ( builtin[i].file == name ) {
        return TRUE;
    }
    }
    return FALSE;
 }
 Global::Command* Global::builtin=0;
 QGuardedPtr<QWidget> *Global::running=0;
 /*!
  \class Global::Command
  \brief The Global::Command class is internal.
  \internal
 */
 /*!
  \internal
 */
 void Global::setBuiltinCommands( Command* list )
 {
    if ( running )
    delete [] running;
    builtin = list;
    int count = 0;
    if (!builtin)
    return;
    while ( builtin[count].file )
    count++;
    running = new QGuardedPtr<QWidget> [ count ];
 }
 /*!
  \internal
 */
 void Global::setDocument( QWidget* receiver, const QString& document )
 {
    Emitter emitter(receiver,document);
 }
 /*!
  \internal
 */
 bool Global::terminateBuiltin( const QString& n )
 {
    if (!builtin)
    return FALSE;
    for (int i = 0; builtin[i].file; i++) {
    if ( builtin[i].file == n ) {
        delete running[i];
        return TRUE;
    }
    }
    return FALSE;
 }
 /*!
  \internal
 */
 void Global::terminate( const AppLnk* app )
 {
    //if ( terminateBuiltin(app->exec()) ) return; // maybe? haven't tried this
 #ifndef QT_NO_COP
    QCString channel = "QPE/Application/" + app->exec().utf8();
    if ( QCopChannel::isRegistered(channel) ) {
    QCopEnvelope e(channel, "quit()");
    }
 #endif
 }
 /*!
  Low-level function to run command \a c.
  \warning Do not use this function. Use execute instead.
  \sa execute()
 */
 void Global::invoke(const QString &c)
 {
    // Convert the command line in to a list of arguments
    QStringList list = QStringList::split(QRegExp("  *"),c);
 #if !defined(QT_NO_COP)
    QString ap=list[0];
    // see if the application is already running
    // XXX should lock file /tmp/qcop-msg-ap
    if ( QCopChannel::isRegistered( ("QPE/Application/" + ap).latin1() ) ) {
    // If the channel is already register, the app is already running, so show it.
    { QCopEnvelope env( ("QPE/Application/" + ap).latin1(), "raise()" ); }
    //QCopEnvelope e("QPE/System", "notBusy(QString)" );
    //e << ap;
    return;
    }
    // XXX should unlock file /tmp/qcop-msg-ap
    //see if it is being started
    if ( StartingAppList::isStarting( ap ) ) {
        // FIXME take it out for now, since it leads to a much to short showing of wait if
        // some entry is clicked.
        // Real cause is that ::execute is called twice for document tab. But it would need some larger changes
        // to fix that, and with future syncs with qtopia 1.6 it will change anyway big time since somebody there
        // had the idea that an apploader belongs to the launcher ...
    //QCopEnvelope e("QPE/System", "notBusy(QString)" );
    //e << ap;
    return;
    }
 #endif
 #ifdef QT_NO_QWS_MULTIPROCESS
    QMessageBox::warning( 0, "Error", "Could not find the application " + c, "Ok", 0, 0, 0, 1 );
 #else
    QStrList slist;
    unsigned int j;
    for ( j = 0; j < list.count(); j++ )
    slist.append( list[j].utf8() );
    const char **args = new const char *[slist.count() + 1];
    for ( j = 0; j < slist.count(); j++ )
    args[j] = slist.at(j);
    args[j] = NULL;
 #if !defined(QT_NO_COP)
    // an attempt to show a wait...
    // more logic should be used, but this will be fine for the moment...
    QCopEnvelope ( "QPE/System", "busy()" );
 #endif
 #ifdef HAVE_QUICKEXEC
 #ifdef Q_OS_MACX
    QString libexe = qpeDir()+"/binlib/lib"+args[0] + ".dylib";
 #else
    QString libexe = qpeDir()+"/binlib/lib"+args[0] + ".so";
 #endif
    qDebug("libfile = %s", libexe.latin1() );
    if ( QFile::exists( libexe ) ) {
    qDebug("calling quickexec %s", libexe.latin1() );
    quickexecv( libexe.utf8().data(), (const char **)args );
    } else
 #endif
    {
        bool success = false;
        int pfd [2];
        if ( ::pipe ( pfd ) < 0 )
            pfd [0] = pfd [1] = -1;
        pid_t pid = ::fork ( );
        if ( pid == 0 ) { // child
            for ( int fd = 3; fd < 100; fd++ ) {
                if ( fd != pfd [1] )
                    ::close ( fd );
            }
            ::setpgid ( ::getpid ( ), ::getppid ( ));
            // Closing of fd[1] indicates that the execvp succeeded!
            if ( pfd [1] >= 0 )
                ::fcntl ( pfd [1], F_SETFD, FD_CLOEXEC );
            // Try bindir first, so that foo/bar works too
            ::execv ( qpeDir ( ) + "/bin/" + args [0], (char * const *) args );
            ::execvp ( args [0], (char * const *) args );
            char resultByte = 1;
            if ( pfd [1] >= 0 )
                ::write ( pfd [1], &resultByte, 1 );
            ::_exit ( -1 );
        }
        else if ( pid > 0 ) {
            success = true;
            if ( pfd [1] >= 0 )
                ::close ( pfd [1] );
            if ( pfd [0] >= 0 ) {
                while ( true ) {
                    char resultByte;
                    int n = ::read ( pfd [0], &resultByte, 1 );
                    if ( n == 1 ) {
                        success = false;
diff --git a/noncore/apps/advancedfm/output.cpp b/noncore/apps/advancedfm/output.cpp
index 8c585f4..8f654d5 100644
--- a/noncore/apps/advancedfm/output.cpp
+++ b/noncore/apps/advancedfm/output.cpp
@@ -1,281 +1,282 @@
 /****************************************************************************
 ** outputEdit.cpp
 **
 ** Copyright: Fri Apr 12 15:12:58 2002 L.J. Potter <ljp@llornkcor.com>
 ****************************************************************************/
 #include "output.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <qpe/qpeapplication.h>
 #include <qpe/applnk.h>
 using namespace Opie::Core;
 /* QT */
 #include <qfile.h>
 #include <qmultilineedit.h>
 #include <qpushbutton.h>
 #include <qlayout.h>
 /* STD */
 #include <errno.h>
 /* XPM */
 static char * filesave_xpm[] = {
 "16 16 78 1",
 "   c None",
 ".  c #343434",
 "+  c #A0A0A0",
 "@  c #565656",
 "#  c #9E9E9E",
 "$  c #525252",
 "%  c #929292",
 "&  c #676767",
 "*  c #848484",
 "=  c #666666",
 "-  c #D8D8D8",
 ";  c #FFFFFF",
 ">  c #DBDBDB",
 ",  c #636363",
 "'  c #989898",
 ")  c #2D2D2D",
 "!  c #909090",
 "~  c #AEAEAE",
 "{  c #EAEAEA",
 "]  c #575757",
 "^  c #585858",
 "/  c #8A8A8A",
 "(  c #828282",
 "_  c #6F6F6F",
 ":  c #C9C9C9",
 "<  c #050505",
 "[  c #292929",
 "}  c #777777",
 "|  c #616161",
 "1  c #3A3A3A",
 "2  c #BEBEBE",
 "3  c #2C2C2C",
 "4  c #7C7C7C",
 "5  c #F6F6F6",
 "6  c #FCFCFC",
 "7  c #6B6B6B",
 "8  c #959595",
 "9  c #4F4F4F",
 "0  c #808080",
 "a  c #767676",
 "b  c #818181",
 "c  c #B8B8B8",
 "d  c #FBFBFB",
 "e  c #F9F9F9",
 "f  c #CCCCCC",
 "g  c #030303",
 "h  c #737373",
 "i  c #7A7A7A",
 "j  c #7E7E7E",
 "k  c #6A6A6A",
 "l  c #FAFAFA",
 "m  c #505050",
 "n  c #9D9D9D",
 "o  c #333333",
 "p  c #7B7B7B",
 "q  c #787878",
 "r  c #696969",
 "s  c #494949",
 "t  c #555555",
 "u  c #949494",
 "v  c #E6E6E6",
 "w  c #424242",
 "x  c #515151",
 "y  c #535353",
 "z  c #3E3E3E",
 "A  c #D4D4D4",
 "B  c #0C0C0C",
 "C  c #353535",
 "D  c #474747",
 "E  c #ECECEC",
 "F  c #919191",
 "G  c #7D7D7D",
 "H  c #000000",
 "I  c #404040",
 "J  c #858585",
 "K  c #323232",
 "L  c #D0D0D0",
 "M  c #1C1C1C",
 "    ...+        ",
 "   @#$%&..+     ",
 "   .*=-;;>,..+  ",
 "  ')!~;;;;;;{]..",
 "  ^/(-;;;;;;;_:<",
 "  [}|;;;;;;;{12$",
 " #34-55;;;;678$+",
 " 90ab=c;dd;e1fg ",
 " [ahij((kbl0mn$ ",
 " op^q^^7r&]s/$+ ",
 "@btu;vbwxy]zAB  ",
 "CzDEvEv;;DssF$  ",
 "G.H{E{E{IxsJ$+  ",
 "  +...vEKxzLM   ",
 "     +...z]n$   ",
 "        +...    "};
 Output::Output( const QStringList commands, QWidget* parent,  const char* name, bool modal, WFlags fl)
    : QDialog( parent, name, modal, fl )
 {
   QStringList cmmds;
 //   cmmds=QStringList::split( " ", commands, false);
   cmmds=commands;
 //   odebug << "count " << cmmds.count() << "" << oendl; 
   if ( !name )
       setName( tr("Output"));
    resize( 196, 269 );
    setCaption( name );
    OutputLayout = new QGridLayout( this );
    OutputLayout->setSpacing( 2);
    OutputLayout->setMargin( 2);
    QPushButton *docButton;
     docButton = new QPushButton(  QPixmap(( const char** ) filesave_xpm  ) ,"",this,"saveButton");
     docButton->setFixedSize( QSize( 20, 20 ) );
     connect( docButton,SIGNAL(released()),this,SLOT( saveOutput() ));
 //    docButton->setFlat(TRUE);
     OutputLayout->addMultiCellWidget( docButton, 0,0,3,3 );
    OutputEdit = new QMultiLineEdit( this, "OutputEdit" );
    OutputLayout->addMultiCellWidget( OutputEdit, 1,1,0,3 );
    proc = new OProcess();
    connect(proc, SIGNAL(processExited(Opie::Core::OProcess*)),
            this, SLOT( processFinished()));
    connect(proc, SIGNAL(receivedStdout(Opie::Core::OProcess*,char*,int)),
            this, SLOT(commandStdout(Opie::Core::OProcess*,char*,int)));
    connect(proc, SIGNAL(receivedStderr(Opie::Core::OProcess*,char*,int)),
            this, SLOT(commandStderr(Opie::Core::OProcess*,char*,int)));
 //     connect( , SIGNAL(received(const QByteArray&)),
 //             this, SLOT(commandStdin(const QByteArray&)));
 //    * proc << commands.latin1();
      for ( QStringList::Iterator it = cmmds.begin(); it != cmmds.end(); ++it ) {
         odebug << "" << (*it).latin1() << "" << oendl; 
         * proc << (*it).latin1();
      }
     if(!proc->start(OProcess::NotifyOnExit, OProcess::All)) {
         OutputEdit->append(tr("Process could not start") );
         OutputEdit->setCursorPosition( OutputEdit->numLines() + 1,0,FALSE);
         perror("Error: ");
         QString errorMsg=tr("Error\n")+(QString)strerror(errno);
         OutputEdit->append( errorMsg);
         OutputEdit->setCursorPosition( OutputEdit->numLines() + 1,0,FALSE);
     }
 }
 Output::~Output() {
 }
 void Output::saveOutput() {
    InputDialog *fileDlg;
    fileDlg = new InputDialog(this,tr("Save output to file (name only)"),TRUE, 0);
    fileDlg->exec();
    if( fileDlg->result() == 1 ) {
      QString  filename = QPEApplication::documentDir();
      if(filename.right(1).find('/') == -1)
          filename+="/";
      QString name = fileDlg->LineEdit1->text();
      filename+="text/plain/"+name;
      odebug << filename << oendl; 
      QFile f(filename);
-      f.open( IO_WriteOnly);
+      if ( !f.open( IO_WriteOnly ) )
-      if( f.writeBlock( OutputEdit->text(), qstrlen( OutputEdit->text()) ) != -1) {
+          owarn << "Could no open file" << oendl;
+      else if( f.writeBlock( OutputEdit->text(), qstrlen( OutputEdit->text()) ) != -1) {
          DocLnk lnk;
          lnk.setName(name); //sets file name
          lnk.setFile(filename); //sets File property
          lnk.setType("text/plain");
          if(!lnk.writeLink()) {
              odebug << "Writing doclink did not work" << oendl; 
          }
      } else
          owarn << "Could not write file" << oendl; 
      f.close();
    }
 }
 void Output::commandStdout(OProcess*, char *buffer, int buflen) {
    owarn << "received stdout " << buflen << " bytes" << oendl; 
 //     QByteArray data(buflen);
 //     data.fill(*buffer, buflen);
 //     for (uint i = 0; i < data.count(); i++ ) {
 //         printf("%c", buffer[i] );
 //     }
 //     printf("\n");
    QString lineStr = buffer;
    lineStr=lineStr.left(lineStr.length()-1);
    OutputEdit->append(lineStr);
    OutputEdit->setCursorPosition( OutputEdit->numLines() + 1,0,FALSE);
 }
 void Output::commandStdin( const QByteArray &data) {
    owarn << "received stdin  " << data.size() << " bytes" << oendl; 
    // recieved data from the io layer goes to sz
    proc->writeStdin(data.data(), data.size());
 }
 void Output::commandStderr(OProcess*, char *buffer, int buflen) {
    owarn << "received stderrt " << buflen << " bytes" << oendl; 
    QString lineStr = buffer;
 //    lineStr=lineStr.left(lineStr.length()-1);
    OutputEdit->append(lineStr);
    OutputEdit->setCursorPosition( OutputEdit->numLines() + 1,0,FALSE);
 }
 void Output::processFinished() {
    delete proc;
    OutputEdit->append( tr("\nFinished\n") );
    OutputEdit->setCursorPosition( OutputEdit->numLines() + 1,0,FALSE);
 //    close();
 //     disconnect( layer(), SIGNAL(received(const QByteArray&)),
 //                this, SLOT(commandStdin(const QByteArray&)));
 }
 //==============================
 InputDialog::InputDialog( QWidget* parent,  const char* name, bool modal, WFlags fl )
    : QDialog( parent, name, modal, fl )
 {
    if ( !name )
        setName( "InputDialog" );
    resize( 234, 50 );
    setMaximumSize( QSize( 240, 50 ) );
    setCaption( tr(name ) );
    LineEdit1 = new QLineEdit( this, "LineEdit1" );
    LineEdit1->setGeometry( QRect( 10, 10, 216, 22 ) );
    LineEdit1->setFocus();
    LineEdit1->setFocus();
    connect(LineEdit1,SIGNAL(returnPressed()),this,SLOT(returned() ));
 }
 InputDialog::~InputDialog() {
    inputText = LineEdit1->text();
 }
 void InputDialog::setInputText(const QString &string) {
    LineEdit1->setText( string);
 }
 void InputDialog::returned() {
    inputText = LineEdit1->text();
    this->accept();
 }
diff --git a/noncore/apps/tinykate/libkate/document/katebuffer.cpp b/noncore/apps/tinykate/libkate/document/katebuffer.cpp
index 4c15fd0..d89edbd 100644
--- a/noncore/apps/tinykate/libkate/document/katebuffer.cpp
+++ b/noncore/apps/tinykate/libkate/document/katebuffer.cpp
@@ -1,180 +1,183 @@
 /*
   This file is part of KWrite
   Copyright (c) 2000 Waldo Bastian <bastian@kde.org>
   Copyright (c) 2002 Joseph Wenninger <jowenn@kde.org>
   $Id$
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License version 2 as published by the Free Software Foundation.
   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 "katebuffer.h"
 #include "kdebug.h"
 /* OPIE */
 #include <opie2/odebug.h>
 /* QT */
 #include <qfile.h>
 #include <qtextstream.h>
 #include <qtimer.h>
 #include <qtextcodec.h>
 /* STD */
 // Includes for reading file
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
 #include <errno.h>
 #include <unistd.h>
 #include <assert.h>
 /**
 * Create an empty buffer.
 */
 KWBuffer::KWBuffer()
 {
   clear();
 }
 void
 KWBuffer::clear()
 {
 m_stringListIt=0;
 m_stringListCurrent=0;
 m_stringList.clear();
 m_lineCount=1;
 m_stringListIt = m_stringList.append(new TextLine());
 }
 /**
 * Insert a file at line @p line in the buffer.
 */
 void
 KWBuffer::insertFile(int line, const QString &file, QTextCodec *codec)
 {
    if (line) {
        odebug << "insert File only supports insertion at line 0 == file opening" << oendl;
        return;
    }
    clear();
    QFile iofile(file);
-    iofile.open(IO_ReadOnly);
+    if (!iofile.open(IO_ReadOnly)) {
+        owarn << "failed to open file " << iofile.name() << oendl;
+        return;
+    }
    QTextStream stream(&iofile);
    stream.setCodec(codec);
    QString qsl;
    int count=0;
    for (count=0;((qsl=stream.readLine())!=QString::null);  count++)
    {
        if (count==0)
        {
            (*m_stringListIt)->append(qsl.unicode(),qsl.length());
        }
        else
        {
            TextLine::Ptr tl=new TextLine();
            tl ->append(qsl.unicode(),qsl.length());
            m_stringListIt=m_stringList.append(tl);
        }
    }
    if (count!=0)
    {
        m_stringListCurrent=count-1;
        m_lineCount=count;
    }
 }
 void
 KWBuffer::loadFilePart()
 {
 }
 void
 KWBuffer::insertData(int line, const QByteArray &data, QTextCodec *codec)
 {
 }
 void
 KWBuffer::slotLoadFile()
 {
  loadFilePart();
 //  emit linesChanged(m_totalLines);
  emit linesChanged(20);
 }
 /**
 * Return the total number of lines in the buffer.
 */
 int
 KWBuffer::count()
 {
  odebug << "m_stringList.count " << m_stringList.count() << "" << oendl;
  return m_lineCount;
 //  return m_stringList.count();
 //   return m_totalLines;
 }
 void KWBuffer::seek(int i)
 {
   if (m_stringListCurrent == i)
      return;
   while(m_stringListCurrent < i)
   {
      ++m_stringListCurrent;
      ++m_stringListIt;
   }
   while(m_stringListCurrent > i)
   {
      --m_stringListCurrent;
      --m_stringListIt;
   }
 }
 TextLine::Ptr
 KWBuffer::line(int i)
 {
    if (i>=m_stringList.count()) return 0;
    seek(i);
    return *m_stringListIt;
 }
 void
 KWBuffer::insertLine(int i, TextLine::Ptr line)
 {
   seek(i);
   m_stringListIt = m_stringList.insert(m_stringListIt, line);
   m_stringListCurrent = i;
   m_lineCount++;
 }
 void
 KWBuffer::removeLine(int i)
 {
   seek(i);
   m_stringListIt = m_stringList.remove(m_stringListIt);
   m_stringListCurrent = i;
   m_lineCount--;
 }
 void
 KWBuffer::changeLine(int i)
 {
 }
diff --git a/noncore/settings/usermanager/userdialog.cpp b/noncore/settings/usermanager/userdialog.cpp
index 3654639..75a96a6 100644
--- a/noncore/settings/usermanager/userdialog.cpp
+++ b/noncore/settings/usermanager/userdialog.cpp
@@ -1,489 +1,492 @@
 /***************************************************************************
 *                                                                         *
 *   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 "userdialog.h"
 #include "passwd.h"
 /* OPIE */
 #include <opie2/odebug.h>
 #include <opie2/odevice.h>
 #include <opie2/oresource.h>
 #include <qpe/qpeapplication.h>
 using namespace Opie::Core;
 using namespace Opie::Ui;
 /* QT */
 #include <qlayout.h>
 #include <qlabel.h>
 #include <qmessagebox.h>
 #include <qfile.h>
 /* STD */
 #include <sys/types.h>
 #include <sys/wait.h>
 #include <unistd.h>
 #include <signal.h>
 /**
 * UserDialog constructor. Setup the dialog, fill the groupComboBox & groupsListView with all groups.
 *
 */
 UserDialog::UserDialog(int viewmode, QWidget* parent, const char* name, bool modal, WFlags fl) : QDialog(parent, name, modal, fl)
 {
    vm=viewmode;
    QVBoxLayout *layout = new QVBoxLayout(this);
    myTabWidget=new QTabWidget(this,"User Tab Widget");
    layout->addWidget(myTabWidget);
    setupTab1();
    setupTab2();
    accounts->groupStringList.sort();
    // And also fill the listview & the combobox with all available groups.
    for( QStringList::Iterator it = accounts->groupStringList.begin(); it!=accounts->groupStringList.end(); ++it)
    {
        accounts->splitGroupEntry(*it);
        if(accounts->gr_name.find(QRegExp("^#"),0))
        {    // Skip commented lines.
            new QCheckListItem(groupsListView,accounts->gr_name,QCheckListItem::CheckBox);
            groupComboBox->insertItem(accounts->gr_name);
        }
    }
    QPEApplication::showDialog( this );
 }
 /**
 * Empty destructor.
 *
 */
 UserDialog::~UserDialog()
 {}
 /**
 *  Creates the first tab, all userinfo is here.
 *
 */
 void UserDialog::setupTab1()
 {
    QPixmap mypixmap;
    QWidget *tabpage = new QWidget(myTabWidget,"page1");
    QVBoxLayout *layout = new QVBoxLayout(tabpage);
    layout->setMargin(5);
    // Picture
    picturePushButton = new QPushButton(tabpage,"Label");
    picturePushButton->setMinimumSize(48,48);
    picturePushButton->setMaximumSize(48,48);
    picturePushButton->setPixmap(Opie::Core::OResource::loadPixmap("usermanager/usericon"));    // Load default usericon.
    connect(picturePushButton,SIGNAL(clicked()),this,SLOT(clickedPicture()));    // Clicking the picture should invoke pictureselector.
    // Login
    QLabel *loginLabel=new QLabel(tabpage,"Login: ");
    loginLabel->setText("Login: ");
    loginLineEdit=new QLineEdit(tabpage,"Login: ");
    // UID
    QLabel *uidLabel=new QLabel(tabpage,"uid: ");
    uidLabel->setText("UserID: ");
    uidLineEdit=new QLineEdit(tabpage,"uid: ");
    uidLineEdit->setEnabled(false);
    // Username (gecos)
    QLabel *gecosLabel=new QLabel(tabpage,"gecos");
    gecosLabel->setText("Username: ");
    gecosLineEdit=new QLineEdit(tabpage,"gecos");
    // Password
    QLabel *passwordLabel=new QLabel(tabpage,"password");
    passwordLabel->setText("Password: ");
    passwordLineEdit=new QLineEdit(tabpage,"password");
    passwordLineEdit->setEchoMode(QLineEdit::Password);
    // Shell
    QLabel *shellLabel=new QLabel(tabpage,"shell");
    shellLabel->setText("Shell: ");
    shellComboBox=new QComboBox(tabpage,"shell");
    shellComboBox->setEditable(true);
    shellComboBox->insertItem("/bin/sh");
    shellComboBox->insertItem("/bin/ash");
    shellComboBox->insertItem("/bin/false");
    // Primary Group
    QLabel *groupLabel=new QLabel(tabpage,"group");
    groupLabel->setText("Primary group: ");
    groupComboBox=new QComboBox(tabpage,"PrimaryGroup");
    if(vm==VIEWMODE_NEW)
    {
        // Copy /etc/skel
        skelLabel=new QLabel(tabpage,"skel");
        skelLabel->setText("Copy /etc/skel: ");
        skelCheckBox=new QCheckBox(tabpage);
        skelCheckBox->setChecked(true);
    }
    // Widget layout
    QHBoxLayout *hlayout=new QHBoxLayout(-1,"hlayout");
    layout->addWidget(picturePushButton);
    layout->addSpacing(5);
    layout->addLayout(hlayout);
    QVBoxLayout *vlayout1=new QVBoxLayout(-1,"vlayout1");
    QVBoxLayout *vlayout2=new QVBoxLayout(-1,"vlayout2");
    // First column, labels
    vlayout1->addWidget(loginLabel);
    vlayout1->addSpacing(5);
    vlayout1->addWidget(uidLabel);
    vlayout1->addSpacing(5);
    vlayout1->addWidget(gecosLabel);
    vlayout1->addSpacing(5);
    vlayout1->addWidget(passwordLabel);
    vlayout1->addSpacing(5);
    vlayout1->addWidget(shellLabel);
    vlayout1->addSpacing(5);
    vlayout1->addWidget(groupLabel);
    if(vm==VIEWMODE_NEW)
    {
        vlayout1->addSpacing(5);
        vlayout1->addWidget(skelLabel);
    }
    // Second column, data
    vlayout2->addWidget(loginLineEdit);
    vlayout2->addSpacing(5);
    vlayout2->addWidget(uidLineEdit);
    vlayout2->addSpacing(5);
    vlayout2->addWidget(gecosLineEdit);
    vlayout2->addSpacing(5);
    vlayout2->addWidget(passwordLineEdit);
    vlayout2->addSpacing(5);
    vlayout2->addWidget(shellComboBox);
    vlayout2->addSpacing(5);
    vlayout2->addWidget(groupComboBox);
    if(vm==VIEWMODE_NEW)
    {
        vlayout2->addSpacing(5);
        vlayout2->addWidget(skelCheckBox);
    }
    hlayout->addLayout(vlayout1);
    hlayout->addLayout(vlayout2);
    myTabWidget->addTab(tabpage,"User Info");
 }
 /**
 *  Creates the second tab containing additional groups for the user.
 *
 */
 void UserDialog::setupTab2()
 {
    QWidget *tabpage = new QWidget(myTabWidget,"page2");
    QVBoxLayout *layout = new QVBoxLayout(tabpage);
    layout->setMargin(5);
    // Additional groups
    groupsListView=new QListView(tabpage,"groups");
    groupsListView->addColumn("Additional groups");
    groupsListView->setColumnWidthMode(0,QListView::Maximum);
    groupsListView->setMultiSelection(false);
    groupsListView->setAllColumnsShowFocus(false);
    layout->addSpacing(5);
    // Grouplist
    layout->addWidget(groupsListView);
    myTabWidget->addTab(tabpage,"User Groups");
 }
 /**
 * Static function that creates the userinfo dialog.
 * The user will be prompted to add a user.
 *
 * @param uid This is a suggested available UID.
 * @param gid This is a suggested available GID.
 *
 * @return <code>true</code> if the user was successfully added, otherwise <code>false</code>.
 *
 */
 bool UserDialog::addUser(int uid, int gid)
 {
    QCheckListItem *temp;
    QFile ozTest;
    int oz=false;
    if(ODevice::inst()->system()==System_OpenZaurus) oz=true;
    // viewmode is a workaround for a bug in qte-2.3.4 that gives bus error on manipulating adduserDialog's widgets here.
    UserDialog *adduserDialog=new UserDialog(VIEWMODE_NEW);
    adduserDialog->setCaption(tr("Add User"));
    adduserDialog->userID=uid;    // Set next available UID as default uid.
    adduserDialog->groupID=gid;    // Set next available GID as default gid.
    // Insert default group into groupComboBox
    adduserDialog->groupComboBox->insertItem("<create new group>",0);
    adduserDialog->uidLineEdit->setText(QString::number(uid));
    // If we're running on OZ, add new users to some default groups.
    if(oz)
    {
        QListViewItemIterator iter( adduserDialog->groupsListView );
        for ( ; iter.current(); ++iter )
        {
            temp=(QCheckListItem*)iter.current();
            if (temp->text()=="video") temp->setOn(true);
            if (temp->text()=="audio") temp->setOn(true);
            if (temp->text()=="time") temp->setOn(true);
            if (temp->text()=="power") temp->setOn(true);
            if (temp->text()=="input") temp->setOn(true);
            if (temp->text()=="sharp") temp->setOn(true);
            if (temp->text()=="tty") temp->setOn(true);
        }
    }
    // Show the dialog!
    if(!(adduserDialog->exec())) return false;
    if((adduserDialog->groupComboBox->currentItem()!=0))
    {
-        accounts->findGroup(adduserDialog->groupComboBox->currentText());
+        // making the call findGroup() puts the group info in the accounts gr_gid
-        adduserDialog->groupID=accounts->gr_gid;
+        if (accounts->findGroup(adduserDialog->groupComboBox->currentText()))
-        owarn << QString::number(accounts->gr_gid) << oendl; 
+        {
+            adduserDialog->groupID=accounts->gr_gid;
+            owarn << QString::number(accounts->gr_gid) << oendl;
+        }
    }
    if(!(accounts->addUser(adduserDialog->loginLineEdit->text(), adduserDialog->passwordLineEdit->text(),
                           adduserDialog->uidLineEdit->text().toInt(), adduserDialog->groupID, adduserDialog->gecosLineEdit->text(),
                           QString("/home/")+adduserDialog->loginLineEdit->text() , adduserDialog->shellComboBox->currentText())))
    {
        QMessageBox::information(0,"Ooops!","Something went wrong!\nUnable to add user.");
        return false;
    }
    // Add User to additional groups.
    QListViewItemIterator it( adduserDialog->groupsListView );
    for ( ; it.current(); ++it )
    {
        temp=(QCheckListItem*)it.current();
        if (temp->isOn() )
            accounts->addGroupMember(it.current()->text(0),adduserDialog->loginLineEdit->text());
    }
    // Copy image to pics/users/
    if(!(adduserDialog->userImage.isNull()))
    {
        QDir d;
        if(!(d.exists(QPEApplication::qpeDir() + "pics/users")))
        {
            d.mkdir(QPEApplication::qpeDir() + "pics/users");
        }
        QString filename= QPEApplication::qpeDir()+"pics/users/"+accounts->pw_name+".png";
        //        adduserDialog->userImage=adduserDialog->userImage.smoothScale(48,48);
        adduserDialog->userImage.save(filename,"PNG");
    }
    // Should we copy the skeleton homedirectory /etc/skel to the user's homedirectory?
    accounts->findUser(adduserDialog->loginLineEdit->text());
    if(adduserDialog->skelCheckBox->isChecked())
    {
        QString command_cp;
        QString command_chown;
        command_cp.sprintf("cp -a /etc/skel/* %s/",accounts->pw_dir.latin1());
        system(command_cp);
        command_cp.sprintf("cp -a /etc/skel/.[!.]* %s/",accounts->pw_dir.latin1());    // Bug in busybox, ".*" includes parent directory, does this work as a workaround?
        system(command_cp);
        command_chown.sprintf("chown -R %d:%d %s",accounts->pw_uid,accounts->pw_gid,accounts->pw_dir.latin1());
        system(command_chown);
    }
    return true;
 }
 /**
 * Deletes the user account.
 *
 * @param username User to be deleted.
 *
 * @return <code>true</code> if the user was successfully deleted, otherwise <code>false</code>.
 *
 */
 bool UserDialog::delUser(const char *username)
 {
    if((accounts->findUser(username)))
    {    // Does that user exist?
        if(!(accounts->delUser(username)))
        {    // Delete the user.
            QMessageBox::information(0,"Ooops!","Something went wrong\nUnable to delete user: "+QString(username)+".");
        }
    }
    else
    {
        QMessageBox::information(0,"Invalid Username","That username ("+QString(username)+")does not exist.");
        return false;
    }
    return true;
 }
 /**
 * This displays a confirmation dialog wether a user should be deleted or not.
 *  (And also deletes the account)
 *
 * @param username User to be deleted.
 *
 * @return <code>true</code> if the user was successfully deleted, otherwise <code>false</code>.
 *
 */
 bool UserDialog::editUser(const char *username)
 {
    int invalid_group=0;
    // viewmode is a workaround for a bug in qte-2.3.4 that gives bus error on manipulating edituserDialog's widgets here.
    UserDialog *edituserDialog=new UserDialog(VIEWMODE_EDIT);    // Create Dialog
    edituserDialog->setCaption(tr("Edit User"));
    accounts->findUser(username);    // Locate user in database and fill variables in 'accounts' object.
    if(!(accounts->findGroup(accounts->pw_gid)))
    {    // Locate the user's primary group, and fill group variables in 'accounts' object.
        invalid_group=1;
    }
    // Fill widgets with userinfo.
    edituserDialog->loginLineEdit->setText(accounts->pw_name);
    edituserDialog->uidLineEdit->setText(QString::number(accounts->pw_uid));
    edituserDialog->gecosLineEdit->setText(accounts->pw_gecos);
    // Set password to '........', we will later check if this still is the contents, if not, the password has been changed.
    edituserDialog->passwordLineEdit->setText("........");
    // If this user is not using /bin/sh,/bin/ash or /bin/false as shell, add that entry to the shell-combobox.
    if(accounts->pw_shell!="/bin/sh" && accounts->pw_shell!="/bin/ash" && accounts->pw_shell!="/bin/false")
    {
        edituserDialog->shellComboBox->insertItem(accounts->pw_shell,0);
        edituserDialog->shellComboBox->setCurrentItem(0);
    }
    // Select the primary group for this user.
    for(int i=0;i<edituserDialog->groupComboBox->count();++i)
    {
        if(accounts->gr_name==edituserDialog->groupComboBox->text(i))
        {
            edituserDialog->groupComboBox->setCurrentItem(i);
            break;
        }
    }
    if(invalid_group)
    {
        edituserDialog->groupComboBox->insertItem("<Undefined group>",0);
        edituserDialog->groupComboBox->setCurrentItem(0);
    }
    // Select the groups in the listview, to which the user belongs.
    QCheckListItem *temp;
    // BAH!!! QRegExp in qt2 sucks... or maybe I do... can't figure out how to check for EITHER end of input ($) OR a comma, so here we do two different QRegExps instead.
    QRegExp userRegExp(QString("[:,]%1$").arg(username));    // The end of line variant.
    QStringList tempList=accounts->groupStringList.grep(userRegExp);    // Find all entries in the group database, that the user is a member of.
    for(QStringList::Iterator it=tempList.begin(); it!=tempList.end(); ++it)
    {    // Iterate over all of them.
        owarn << *it << oendl; 
        QListViewItemIterator lvit( edituserDialog->groupsListView );    // Compare to all groups.
        for ( ; lvit.current(); ++lvit )
        {
            if(lvit.current()->text(0)==(*it).left((*it).find(":")))
            {
                temp=(QCheckListItem*)lvit.current();
                temp->setOn(true);    // If we find a line with that groupname, select it.;
            }
        }
    }
    userRegExp=QRegExp(QString("[:,]%1,").arg(username));    // And the other one. (not end of line.)
    tempList=accounts->groupStringList.grep(userRegExp);    // Find all entries in the group database, that the user is a member of.
    for(QStringList::Iterator it=tempList.begin(); it!=tempList.end(); ++it)
    {    // Iterate over all of them.
        owarn << *it << oendl; 
        QListViewItemIterator lvit( edituserDialog->groupsListView );    // Compare to all groups.
        for ( ; lvit.current(); ++lvit )
        {
            if(lvit.current()->text(0)==(*it).left((*it).find(":")))
            {
                temp=(QCheckListItem*)lvit.current();
                temp->setOn(true);    // If we find a line with that groupname, select it.;
            }
        }
    }
    if(!(edituserDialog->exec())) return false;    // SHOW THE DIALOG!
    accounts->findUser(username);    // Fill user variables in 'acccounts' object.
    accounts->pw_name=edituserDialog->loginLineEdit->text();
    // Has the password been changed ? Make a new "crypt":ed password.
    if(edituserDialog->passwordLineEdit->text()!="........") accounts->pw_passwd=crypt(edituserDialog->passwordLineEdit->text(), accounts->crypt_make_salt());
    // Set all variables in accounts object, that will be used when calling 'updateUser()'
    accounts->pw_uid=edituserDialog->uidLineEdit->text().toInt();
    if(accounts->findGroup(edituserDialog->groupComboBox->currentText()))
    {    // Fill all group variables in 'accounts' object.
        accounts->pw_gid=accounts->gr_gid;    // Only do this if the group is a valid group (ie. "<Undefined group>"), otherwise keep the old group.
    }
    accounts->pw_gecos=edituserDialog->gecosLineEdit->text();
    accounts->pw_shell=edituserDialog->shellComboBox->currentText();
    // Update userinfo, using the information stored in the user variables stored in the accounts object.
    accounts->updateUser(username);
    // Remove user from all groups he/she is a member of. (could be done in a better way I guess, this was simple though.)
    for(QStringList::Iterator it=tempList.begin(); it!=tempList.end(); ++it)
    {
        accounts->delGroupMember((*it).left((*it).find(":")),username);
    }
    // Add User to additional groups that he/she is a member of.
    QListViewItemIterator it( edituserDialog->groupsListView );
    for ( ; it.current(); ++it )
    {
        temp=(QCheckListItem*)it.current();
        if ( temp->isOn() )
            accounts->addGroupMember(it.current()->text(0),edituserDialog->loginLineEdit->text());
    }
    // Copy image to pics/users/
    if(!(edituserDialog->userImage.isNull()))
    {
        QDir d;
        if(!(d.exists(QPEApplication::qpeDir()+"pics/users")))
        {
            d.mkdir(QPEApplication::qpeDir()+"pics/users");
        }
        QString filename=QPEApplication::qpeDir()+"pics/users/"+accounts->pw_name+".png";
        //        edituserDialog->userImage=edituserDialog->userImage.smoothScale(48,48);
        edituserDialog->userImage.save(filename,"PNG");
    }
    return true;
 }
 /**
 * "OK" has been clicked. Verify some information before closing the dialog.
 *
 */
 void UserDialog::accept()
 {
    // Add checking... valid username? username taken?
    if(loginLineEdit->text().isEmpty())
    {
        QMessageBox::information(0,"Empty Login","Please enter a login.");
        return;
    }
    QDialog::accept();
 }
 /**
 * This slot is called when the usericon is clicked, this loads (should) the iconselector.
 *
 */
 void UserDialog::clickedPicture()
 {
    QString filename=OFileDialog::getOpenFileName(OFileSelector::EXTENDED, QString::null);
    if(!(filename.isEmpty()))
    {
        userImage.reset();
        if(!(userImage.load(filename)))
        {
            QMessageBox::information(0,"Sorry!","That icon could not be loaded.\nLoading failed on: "+filename);
        }
        else
        {
            //            userImage=userImage.smoothScale(48,48);
            QPixmap *picture;
            picture=(QPixmap *)picturePushButton->pixmap();
            picture->convertFromImage(userImage,0);
            picturePushButton->update();
        }
    }
 }