Re-applied patch for gcc3.2

author: andyq <andyq> 2002-11-21 20:16:40 (UTC)
committer: andyq <andyq> 2002-11-21 20:16:40 (UTC)
commit: 2185394da06d32a3655e71ec022da202477350e7 (patch) (unidiff)
tree: b266ddecaa44a1fef5229bb0525c990d5e7cc51a
parent: 6d302b82aab909da59852d99a31bcc7726ba9f34 (diff)
download: opie-2185394da06d32a3655e71ec022da202477350e7.zip
opie-2185394da06d32a3655e71ec022da202477350e7.tar.gz
opie-2185394da06d32a3655e71ec022da202477350e7.tar.bz2
10 files changed, 37 insertions, 41 deletions
diff --git a/noncore/settings/aqpkg/datamgr.cpp b/noncore/settings/aqpkg/datamgr.cpp
index e7fb75a..96c28c0 100644
--- a/noncore/settings/aqpkg/datamgr.cpp
+++ b/noncore/settings/aqpkg/datamgr.cpp
@@ -1,262 +1,255 @@
 /***************************************************************************
                          datamgr.cpp  -  description
                             -------------------
    begin                : Thu Aug 29 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 <fstream>
 #include <iostream>
 using namespace std;
 #ifdef QWS
 #include <qpe/config.h>
 #endif
 #include <stdio.h>
 #include "datamgr.h"
 #include "global.h"
 QString DataManager::availableCategories = "";
 DataManager::DataManager()
 {
    activeServer = "";
    availableCategories = "#";
 }
 DataManager::~DataManager()
 {
 }
-Server *DataManager :: getServer( const char *name )
+vector<Server>::iterator DataManager :: getServer( const char *name )
 {
-        Server *s = 0;
+    vector<Server>::iterator it = serverList.begin();
-        vector<Server>::iterator it = serverList.begin();
+    while ( it != serverList.end() )
-    while ( it != serverList.end() && s == 0 )
    {
                if ( it->getServerName() == name )
-                        s = &(*it);
+                        return it;
                ++it;
        }
-        return s;
+        return serverList.end();
 }
-Destination *DataManager :: getDestination( const char *name )
+vector<Destination>::iterator DataManager :: getDestination( const char *name )
 {
-        Destination *d = 0;
        vector<Destination>::iterator it = destList.begin();
-    while ( it != destList.end() && d == 0 )
+    while ( it != destList.end() )
    {
                if ( it->getDestinationName() == name )
-                        d = &(*it);
+                        return it;
                ++it;
        }
-        return d;
+        return destList.end();
 }
 void DataManager :: loadServers()
 {
    // First add our local server - not really a server but
    // the local config (which packages are installed)
    serverList.push_back( Server( LOCAL_SERVER, "" ) );
    serverList.push_back( Server( LOCAL_IPKGS, "" ) );
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "destinations" );
 #endif
    // Read file from /etc/ipkg.conf
    QString ipkg_conf = IPKG_CONF;
    FILE *fp;
    fp = fopen( ipkg_conf, "r" );
    char line[130];
    QString lineStr;
    if ( fp == NULL )
    {
        cout << "Couldn't open " << ipkg_conf << "! err = " << fp << endl;
        return;
    }
    else
    {
        while ( fgets( line, sizeof line, fp) != NULL )
        {
            lineStr = line;
            if ( lineStr.startsWith( "src" ) || lineStr.startsWith( "#src" ) || lineStr.startsWith( "# src" ) )
            {
                char alias[20];
                char url[100];
                // Looks a little wierd but read up to the r of src (throwing it away),
                // then read up to the next space and throw that away, the alias
                // is next.
                // Should Handle #src, # src, src, and combinations of
                sscanf( lineStr, "%*[^r]%*[^ ] %s %s", alias, url );
                Server s( alias, url );
                if ( lineStr.startsWith( "src" ) )
                    s.setActive( true );
                else
                    s.setActive( false );
                serverList.push_back( s );
            }
            else if ( lineStr.startsWith( "dest" ) )
            {
                char alias[20];
                char path[50];
                sscanf( lineStr, "%*[^ ] %s %s", alias, path );
                Destination d( alias, path );
                bool linkToRoot = true;
 #ifdef QWS
                QString key = alias;
                key += "_linkToRoot";
                linkToRoot = cfg.readBoolEntry( key, true );
 #endif
                d.linkToRoot( linkToRoot );
                
                destList.push_back( d );
            }
            else if ( lineStr.startsWith( "option" ) )
            {
                char type[20];
                char val[100];
                sscanf( lineStr, "%*[^ ] %s %s", type, val );
                if ( stricmp( type, "http_proxy" ) == 0 )
                    httpProxy = val;
                if ( stricmp( type, "ftp_proxy" ) == 0 )
                    ftpProxy = val;
                if ( stricmp( type, "proxy_username" ) == 0 )
                    proxyUsername = val;
                if ( stricmp( type, "proxy_password" ) == 0 )
                    proxyPassword = val;
            }
        }
    }
    fclose( fp );
-    cout << "httpProxy = " << httpProxy << endl;
-    cout << "ftpProxy = " << ftpProxy << endl;
-    cout << "proxyUsername = " << proxyUsername << endl;
-    cout << "proxyPassword = " << proxyPassword << endl;
    reloadServerData( );
 }
 void DataManager :: reloadServerData( )
 {
        vector<Server>::iterator it = serverList.begin();
    for ( it = serverList.begin() ; it != serverList.end() ; ++it )
    {
            // Now we've read the config file in we need to read the servers
            // The local server is a special case. This holds the contents of the
            // status files the number of which depends on how many destinations
            // we've set up
            // The other servers files hold the contents of the server package list
            if ( it->getServerName() == LOCAL_SERVER )
                it->readStatusFile( destList );
            else if ( it->getServerName() == LOCAL_IPKGS )
-                it->readLocalIpks( getServer( LOCAL_SERVER ) );
+            it->readLocalIpks( &( *getServer( LOCAL_SERVER ) ) );
            else
-                it->readPackageFile( getServer( LOCAL_SERVER ) );
+            it->readPackageFile( &( *getServer( LOCAL_SERVER ) ) );     
        }
 }
 void DataManager :: writeOutIpkgConf()
 {
    QString ipkg_conf = IPKG_CONF;
    ofstream out( ipkg_conf );
    out << "# Written by AQPkg" << endl;
    out << "# Must have one or more source entries of the form:" << endl;
    out << "#" << endl;
    out << "#   src <src-name> <source-url>" << endl;
    out << "#" << endl;
    out << "# and one or more destination entries of the form:" << endl;
    out << "#" << endl;
    out << "#   dest <dest-name> <target-path>" << endl;
    out << "#" << endl;
    out << "# where <src-name> and <dest-names> are identifiers that" << endl;
    out << "# should match [a-zA-Z0-9._-]+, <source-url> should be a" << endl;
    out << "# URL that points to a directory containing a Familiar" << endl;
    out << "# Packages file, and <target-path> should be a directory" << endl;
    out << "# that exists on the target system." << endl << endl;
    
    // Write out servers
    vector<Server>::iterator it = serverList.begin();
    while ( it != serverList.end() )
    {
        QString alias = it->getServerName();
        // Don't write out local as its a dummy
        if ( alias != LOCAL_SERVER && alias != LOCAL_IPKGS )
        {
            QString url = it->getServerUrl();;
            if ( !it->isServerActive() )
                out << "#";
            out << "src " << alias << " " << url << endl;
        }
        it++;
    }
    out << endl;
    // Write out destinations
    vector<Destination>::iterator it2 = destList.begin();
    while ( it2 != destList.end() )
    {
        out << "dest " << it2->getDestinationName() << " " << it2->getDestinationPath() << endl;
        it2++;
    }
    out << "# Proxy Support" << endl;
    out << "#" << endl;
    if ( httpProxy == "" )
        out << "#option http_proxy http://proxy.tld:3128" << endl;
    else
        out << "option http_proxy " << httpProxy << endl;
    if ( ftpProxy == "" )
        out << "#option ftp_proxy http://proxy.tld:3128" << endl;
    else
        out << "option ftp_proxy " << ftpProxy << endl;
    if ( proxyUsername == "" )
        out << "#option proxy_username <username>" << endl;
    else
        out << "option proxy_username " << proxyUsername << endl;
    if ( proxyPassword == "" )
        out << "#option proxy_password <password>" << endl << endl;
    else
        out << "option proxy_password " << proxyPassword << endl<< endl;
    out << "# Offline mode (for use in constructing flash images offline)" << endl;
    out << "#option offline_root target" << endl;
    
    out.close();
 }
 void DataManager :: setAvailableCategories( QString section )
 {
    section = section.lower();
    if ( availableCategories.find( "#" + section + "#" ) == -1 )
        availableCategories += section + "#";
 }
diff --git a/noncore/settings/aqpkg/datamgr.h b/noncore/settings/aqpkg/datamgr.h
index 14b0b2f..41833df 100644
--- a/noncore/settings/aqpkg/datamgr.h
+++ b/noncore/settings/aqpkg/datamgr.h
@@ -1,73 +1,73 @@
 /***************************************************************************
                          datamgr.h  -  description
                             -------------------
    begin                : Thu Aug 29 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 #ifndef DATAMGR_H
 #define DATAMGR_H
 #include <map>
 using namespace std;
 #include <qstring.h>
 #include "server.h"
 #include "destination.h"
        #define LOCAL_SERVER            "Installed Pkgs"
        #define LOCAL_IPKGS                     "local IPKG"
 /**
  *@author Andy Qua
  */
 class DataManager
 {
 public:
    DataManager();
-        ~DataManager();
+    ~DataManager();
    void setActiveServer( const QString &act )      { activeServer = act; }
            QString &getActiveServer( )                         { return activeServer; }
-            Server *getLocalServer()                                    { return getServer( LOCAL_SERVER ); }
+            Server *getLocalServer()                                    { return &( *getServer( LOCAL_SERVER ) ); }
            vector<Server> &getServerList()                     { return serverList; }
-    Server *getServer( const char *name );
+    vector<Server>::iterator getServer( const char *name );
            vector<Destination> &getDestinationList()           { return destList; }
-    Destination *getDestination( const char *name );
+    vector<Destination>::iterator getDestination( const char *name );
    void loadServers();
    void reloadServerData( );
    void writeOutIpkgConf();
    static QString getAvailableCategories() { return availableCategories; }
    static void setAvailableCategories( QString section );
 private:
    static QString availableCategories;
    QString activeServer;
    QString httpProxy;
    QString ftpProxy;
    QString proxyUsername;
    QString proxyPassword;
    vector<Server> serverList;
    vector<Destination> destList;
 };
 #endif
diff --git a/noncore/settings/aqpkg/global.h b/noncore/settings/aqpkg/global.h
index fcec643..ddfb3ac 100644
--- a/noncore/settings/aqpkg/global.h
+++ b/noncore/settings/aqpkg/global.h
@@ -1,80 +1,80 @@
 /***************************************************************************
                          global.h  -  description
                             -------------------
    begin                : Mon Aug 26 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 #ifndef __GLOBAL_H
 #define __GLOBAL_H
-#define VERSION_TEXT "AQPkg Version 1.3"
+#define VERSION_TEXT "AQPkg Version 1.4"
 // Uncomment the below line to run on a Linux box rather than a Zaurus
 // box this allows you to change where root is, and where to load config files from
 // #define X86
 // Sets up location of ipkg.conf and root directory
 #ifdef QWS
 #ifndef X86
 // Running QT/Embedded on an arm processor
 #define IPKG_CONF "/etc/ipkg.conf"
 #define ROOT "/"
 #define IPKG_DIR "/usr/lib/ipkg/"
 #else
 // Running QT/Embedded on a X86 linux box
 #define IPKG_CONF "/home/andy/projects/aqpkg/aqpkg/data/ipkg.conf"
 #define ROOT "/home/andy/projects/aqpkg/aqpkg/data/root"
 #define IPKG_DIR "/home/andy/projects/aqpkg/aqpkg/data/"
 #endif
 #else
 // Running QT on a X86 linux box
 #define IPKG_CONF "/home/andy/projects/aqpkg/aqpkg/data/ipkg.conf"
 #define ROOT "/home/andy/projects/aqpkg/aqpkg/data/root"
 #define IPKG_DIR "/home/andy/projects/aqpkg/aqpkg/data/"
 #endif
 // Uncomment the below line to turn on memory checking
 //#define _DEBUG 1
 #ifndef __MEMFILE_C
 #ifdef _DEBUG
 void * operator new(unsigned int size,const char *file, int line);
 void operator delete(void *p);
 #endif
 #ifdef _DEBUG
 #define DEBUG_NEW new(__FILE__, __LINE__)
 //#define DEBUG_NEW new
 #else
 #define DEBUG_NEW new
 #endif
 #define new DEBUG_NEW
 #endif
 void AddTrack(long addr,  long asize,  const char *fname, long lnum);
 void RemoveTrack(long addr);
 void DumpUnfreed();
 #endif
diff --git a/noncore/settings/aqpkg/installdlgimpl.cpp b/noncore/settings/aqpkg/installdlgimpl.cpp
index b297437..db9a259 100644
--- a/noncore/settings/aqpkg/installdlgimpl.cpp
+++ b/noncore/settings/aqpkg/installdlgimpl.cpp
@@ -1,242 +1,242 @@
 /***************************************************************************
                          installdlgimpl.cpp  -  description
                             -------------------
    begin                : Mon Aug 26 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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.                                   *
 *                                                                         *
 ***************************************************************************/
 #ifdef QWS
 #include <qpe/config.h>
 #endif
 #include <qmultilineedit.h>
 #include <qdialog.h>
 #include <qcombobox.h>
 #include <qcheckbox.h>
 #include <qpushbutton.h>
 #include "datamgr.h"
 #include "instoptionsimpl.h"
 #include "destination.h"
 #include "installdlgimpl.h"
 #include "global.h"
 InstallDlgImpl::InstallDlgImpl( vector<InstallData> &packageList, DataManager *dataManager, QWidget * parent, const char* name, bool modal, WFlags fl )
    : InstallDlg( parent, name, modal, fl )
 {
    pIpkg = 0;
    upgradePackages = false;
    dataMgr = dataManager;
    vector<Destination>::iterator dit;
    QString defaultDest = "root";
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "settings" );
    defaultDest = cfg.readEntry( "dest", "root" );
    // Grab flags - Turn MAKE_LINKS on by default (if no flags found)
    flags = cfg.readNumEntry( "installFlags", 0 );
 #else
        flags = 0;
 #endif
    // Output text is read only
    output->setReadOnly( true );
        QFont f( "helvetica" );
        f.setPointSize( 10 );
        output->setFont( f );
    // setup destination data
    int defIndex = 0;
    int i;
    for ( i = 0 , dit = dataMgr->getDestinationList().begin() ; dit != dataMgr->getDestinationList().end() ; ++dit, ++i )
    {
        destination->insertItem( dit->getDestinationName() );
        if ( dit->getDestinationName() == defaultDest )
            defIndex = i;
    }
    destination->setCurrentItem( defIndex );
        vector<InstallData>::iterator it;
        // setup package data
        QString remove = "Remove\n";
        QString install = "\nInstall\n";
        QString upgrade = "\nUpgrade\n";
        for ( it = packageList.begin() ; it != packageList.end() ; ++it )
        {
                InstallData item = *it;
                if ( item.option == "I" )
                {
                        installList.push_back( item );
                        install += "   " + item.packageName + "\n";
                }
                else if ( item.option == "D" )
                {
                        removeList.push_back( item );
                        remove += "   " + item.packageName + "\n";
                }
                else if ( item.option == "U" || item.option == "R" )
                {
                        updateList.push_back( item );
            QString type = " (Upgrade)";
            if ( item.option == "R" )
                type = " (ReInstall)";
                        upgrade += "   " + item.packageName + type + "\n";
                }
        }
        output->setText( remove + install + upgrade );
 }
 InstallDlgImpl::InstallDlgImpl( Ipkg *ipkg, QString initialText, QWidget *parent, const char *name, bool modal, WFlags fl )
    : InstallDlg( parent, name, modal, fl )
 {
    pIpkg = ipkg;
    output->setText( initialText );
 }
 InstallDlgImpl::~InstallDlgImpl()
 {
 }
 bool InstallDlgImpl :: showDlg()
 {
        showMaximized();
        bool ret = exec();
        return ret;
 }
 void InstallDlgImpl :: optionsSelected()
 {
        InstallOptionsDlgImpl opt( flags, this, "Option", true );
        opt.exec();
        // set options selected from dialog
    flags = 0;
    if ( opt.forceDepends->isChecked() )
        flags |= FORCE_DEPENDS;
    if ( opt.forceReinstall->isChecked() )
        flags |= FORCE_REINSTALL;
    if ( opt.forceRemove->isChecked() )
        flags |= FORCE_REMOVE;
    if ( opt.forceOverwrite->isChecked() )
        flags |= FORCE_OVERWRITE;
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "settings" );
    cfg.writeEntry( "installFlags", flags );
 #endif
 }
 void InstallDlgImpl :: installSelected()
 {
        if ( btnInstall->text() == "Close" )
        {
                done( 1 );
                return;
        }
        btnInstall->setEnabled( false );
    if ( pIpkg )
    {
        output->setText( "" );
        
        connect( pIpkg, SIGNAL(outputText(const QString &)), this, SLOT(displayText(const QString &)));
        pIpkg->runIpkg();
    }
    else
    {
        output->setText( "" );
-        Destination *d = dataMgr->getDestination( destination->currentText() );
+        vector<Destination>::iterator d = dataMgr->getDestination( destination->currentText() );
        QString dest = d->getDestinationName();
        QString destDir = d->getDestinationPath();
        int instFlags = flags;
        if ( d->linkToRoot() )
            instFlags |= MAKE_LINKS;
    
 #ifdef QWS
        // Save settings
        Config cfg( "aqpkg" );
        cfg.setGroup( "settings" );
        cfg.writeEntry( "dest", dest );
 #endif
        pIpkg = new Ipkg;
        connect( pIpkg, SIGNAL(outputText(const QString &)), this, SLOT(displayText(const QString &)));
        
        // First run through the remove list, then the install list then the upgrade list
            vector<InstallData>::iterator it;
        pIpkg->setOption( "remove" );
        for ( it = removeList.begin() ; it != removeList.end() ; ++it )
        {
            pIpkg->setDestination( it->destination->getDestinationName() );
            pIpkg->setDestinationDir( it->destination->getDestinationPath() );
            pIpkg->setPackage( it->packageName );
            int tmpFlags = flags;
            if ( it->destination->linkToRoot() )
                tmpFlags |= MAKE_LINKS;
            
            pIpkg->setFlags( tmpFlags );
            pIpkg->runIpkg();
        }
        pIpkg->setOption( "install" );
        pIpkg->setDestination( dest );
        pIpkg->setDestinationDir( destDir );
        pIpkg->setFlags( instFlags );
        for ( it = installList.begin() ; it != installList.end() ; ++it )
        {
            pIpkg->setPackage( it->packageName );
            pIpkg->runIpkg();
        }
        flags |= FORCE_REINSTALL;
        for ( it = updateList.begin() ; it != updateList.end() ; ++it )
        {
            if ( it->option == "R" )
                pIpkg->setOption( "reinstall" );
            else
                pIpkg->setOption( "upgrade" );
            pIpkg->setDestination( it->destination->getDestinationName() );
            pIpkg->setDestinationDir( it->destination->getDestinationPath() );
            pIpkg->setPackage( it->packageName );
            int tmpFlags = flags;
            if ( it->destination->linkToRoot() && it->recreateLinks )
                tmpFlags |= MAKE_LINKS;
            pIpkg->setFlags( tmpFlags );
            pIpkg->runIpkg();
        }
        delete pIpkg;
    }
        btnInstall->setEnabled( true );
    btnInstall->setText( tr( "Close" ) );
 }
 void InstallDlgImpl :: displayText(const QString &text )
 {
    QString t = output->text() + "\n" + text;
    output->setText( t );
    output->setCursorPosition( output->numLines(), 0 );
 }
diff --git a/noncore/settings/aqpkg/ipkg.cpp b/noncore/settings/aqpkg/ipkg.cpp
index 452eca3..8de3c48 100644
--- a/noncore/settings/aqpkg/ipkg.cpp
+++ b/noncore/settings/aqpkg/ipkg.cpp
@@ -1,444 +1,445 @@
 /***************************************************************************
                          ipkg.cpp  -  description
                             -------------------
    begin                : Sat Aug 31 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 <fstream>
+#include <iostream>
 using namespace std;
 #include <stdio.h>
 #include <unistd.h>
 #ifdef QWS
 #include <qpe/qpeapplication.h>
 #else
 #include <qapplication.h>
 #endif
 #include <qdir.h>
 #include <qtextstream.h>
 #include "utils.h"
 #include "ipkg.h"
 #include "global.h"
 Ipkg :: Ipkg()
 {
 }
 Ipkg :: ~Ipkg()
 {
 }
 // Option is what we are going to do - install, upgrade, download, reinstall
 // package is the package name to install - either a fully qualified path and ipk
 //   file (if stored locally) or just the name of the package (for a network package)
 // packageName is the package name - (for a network package this will be the same as
 //    package parameter)
 // dest is the destination alias (from ipk.conf)
 // destDir is the dir that the destination alias points to (used to link to root)
 // flags is the ipkg options flags
 // dir is the directory to run ipkg in (defaults to "")
 bool Ipkg :: runIpkg( )
 {
    bool ret = false;
    QDir::setCurrent( "/tmp" );
    QString cmd = "";
    if ( runtimeDir != "" )
    {
        cmd += "cd ";
        cmd += runtimeDir;
        cmd += " ; ";
    }
    cmd += "ipkg -force-defaults";
    // only set the destination for an install operation
    if ( option == "install" )
        cmd += " -dest "+ destination;
    if ( option != "update" && option != "download" )
    {
        if ( flags & FORCE_DEPENDS )
            cmd += " -force-depends";
        if ( flags & FORCE_REINSTALL  )
            cmd += " -force-reinstall";
        if ( flags & FORCE_REMOVE )
            cmd += " -force-removal-of-essential-packages";
        if ( flags & FORCE_OVERWRITE )
            cmd += " -force-overwrite";
        // Handle make links
        // Rules - If make links is switched on, create links to root
        // if destDir is NOT /
        if ( flags & MAKE_LINKS )
        {
            // If destDir == / turn off make links as package is being insalled
            // to root already.
            if ( destDir == "/" )
                flags ^= MAKE_LINKS;
        }
    }
    
 #ifdef X86
    cmd += " -f ";
    cmd += IPKG_CONF;
 #endif
    if ( option == "reinstall" )
        cmd += " install";
    else
        cmd += " " + option;
    if ( package != "" )
        cmd += " " + package;
    cmd += " 2>&1";
    if ( package != "" )
        emit outputText( QString( "Dealing with package " ) + package );
    qApp->processEvents();
    // If we are removing packages and make links option is selected
    // create the links
    if ( option == "remove" || option == "reinstall" )
    {
        createLinks = false;
        if ( flags & MAKE_LINKS )
        {
            emit outputText( QString( "Removing symbolic links...\n" ) );
            linkPackage( Utils::getPackageNameFromIpkFilename( package ), destination, destDir );
            emit outputText( QString( " " ) );
        }
    }
    
    emit outputText( cmd );
    // Execute command
    dependantPackages = new QList<QString>;
    dependantPackages->setAutoDelete( true );
    ret = executeIpkgCommand( cmd, option );
    if ( option == "install" || option == "reinstall" )
    {
        // If we are not removing packages and make links option is selected
        // create the links
        createLinks = true;
        if ( flags & MAKE_LINKS )
        {
            emit outputText( " " );
            emit outputText( QString( "Creating symbolic links for " )+ package );
            
            linkPackage( Utils::getPackageNameFromIpkFilename( package ), destination, destDir );
            // link dependant packages that were installed with this release
            QString *pkg;
            for ( pkg = dependantPackages->first(); pkg != 0; pkg = dependantPackages->next() )
            {
                if ( *pkg == package )
                    continue;
                emit outputText( " " );
                emit outputText( QString( "Creating symbolic links for " )+ (*pkg) );
                linkPackage( Utils::getPackageNameFromIpkFilename( *pkg ), destination, destDir );
            }
        }
    }
    delete dependantPackages;
    // Finally, if we are removing a package, remove its entry from the <destdir>/usr/lib/ipkg/status file
    // to workaround an ipkg bug which stops reinstall to a different location
    if ( option == "remove" )
        removeStatusEntry();
    
 //    emit outputText( QString( "Finished - status=" ) + (ret ? "success" : "failure") );
    emit outputText( "Finished" );
    emit outputText( "" );
    return ret;
 }
 void Ipkg :: removeStatusEntry()
 {
    QString statusFile = destDir;
    if ( statusFile.right( 1 ) != "/" )
        statusFile += "/";
    statusFile += "usr/lib/ipkg/status";
    QString outStatusFile = statusFile + ".tmp";
    emit outputText( "" );
    emit outputText( "Removing status entry..." );
    emit outputText( QString( "status file - " )+ statusFile );
    emit outputText( QString( "package - " )+ package );
    
    ifstream in( statusFile );
    ofstream out( outStatusFile );
        if ( !in.is_open() )
    {
        emit outputText( QString( "Couldn't open status file - " )+ statusFile );
        return;
    }
    if ( !out.is_open() )
    {
        emit outputText( QString( "Couldn't create tempory status file - " )+ outStatusFile );
        return;
    }
    char line[1001];
    char k[21];
    char v[1001];
    QString key;
    QString value;
    do
    {
        in.getline( line, 1000 );
        if ( in.eof() )
            continue;
        k[0] = '\0';
        v[0] = '\0';
        sscanf( line, "%[^:]: %[^\n]", k, v );
        key = k;
        value = v;
        key = key.stripWhiteSpace();
        value = value.stripWhiteSpace();
        if ( key == "Package" && value == package )
        {
            // Ignore all lines up to next empty
            do
            {
                in.getline( line, 1000 );
                if ( in.eof() || QString( line ).stripWhiteSpace() == "" )
                    continue;
            } while ( !in.eof() && QString( line ).stripWhiteSpace() != "" );
        }
        out << line << endl;
    } while ( !in.eof() );
    in.close();
    out.close();
    // Remove old status file and put tmp stats file in its place
    remove( statusFile );
    rename( outStatusFile, statusFile );
 }
 int Ipkg :: executeIpkgCommand( QString &cmd, const QString option )
 {
    FILE *fp = NULL;
    char line[130];
    QString lineStr, lineStrOld;
    int ret = false;
    fp = popen( (const char *) cmd, "r");
    if ( fp == NULL )
    {
        cout << "Couldn't execute " << cmd << "! err = " << fp << endl;
        QString text;
        text.sprintf( "Couldn't execute %s! See stdout for error code", (const char *)cmd );
        emit outputText( text );
    }
    else
    {
        while ( fgets( line, sizeof line, fp) != NULL )
        {
            lineStr = line;
            lineStr=lineStr.left( lineStr.length()-1 );
            if ( lineStr != lineStrOld )
            {
                //See if we're finished
                if ( option == "install" || option == "reinstall" )
                {
                    // Need to keep track of any dependant packages that get installed
                    // so that we can create links to them as necessary
                    if ( lineStr.startsWith( "Installing " ) )
                    {
                        int start = lineStr.find( " " ) + 1;
                        int end = lineStr.find( " ", start );
                        QString *package = new QString( lineStr.mid( start, end-start ) );
                        dependantPackages->append( package );
                    }
                }
                
                if ( option == "update" )
                {
                    if (lineStr.contains("Updated list"))
                        ret = true;
                }
                else if ( option == "download" )
                {
                    if (lineStr.contains("Downloaded"))
                        ret = true;
                }
                else
                {
                    if (lineStr.contains("Done"))
                        ret = true;
                }
                emit outputText( lineStr );
            }
            lineStrOld = lineStr;
            qApp->processEvents();
        }
        pclose(fp);
    }
    return ret;
 }
 void Ipkg :: linkPackage( const QString &packFileName, const QString &dest, const QString &destDir )
 {
    if ( dest == "root" || dest == "/" )
        return;
        
    qApp->processEvents();
    QStringList *fileList = getList( packFileName, destDir );
    qApp->processEvents();
    processFileList( fileList, destDir );
    delete fileList;
 }
 QStringList* Ipkg :: getList( const QString &packageFilename, const QString &destDir )
 {
    QString packageFileDir = destDir+"/usr/lib/ipkg/info/"+packageFilename+".list";
    QFile f( packageFileDir );
    cout << "Try to open " << packageFileDir << endl;
    if ( !f.open(IO_ReadOnly) )
    {
        // Couldn't open from dest, try from /
        cout << "Could not open:" << packageFileDir << endl;
        f.close();
        
        packageFileDir = "/usr/lib/ipkg/info/"+packageFilename+".list";
        f.setName( packageFileDir );
 //        cout << "Try to open " << packageFileDir.latin1() << endl;
        if ( ! f.open(IO_ReadOnly) )
        {
            cout << "Could not open:" << packageFileDir << endl;
            emit outputText( QString( "Could not open :" ) + packageFileDir );
            return (QStringList*)0;
        }
    }
    QStringList *fileList = new QStringList();
    QTextStream t( &f );
    while ( !t.eof() )
        *fileList += t.readLine();
    f.close();
    return fileList;
 }
 void Ipkg :: processFileList( const QStringList *fileList, const QString &destDir )
 {
    if ( !fileList || fileList->isEmpty() )
        return;
    QString baseDir = ROOT;
    if ( createLinks == true )
    {
        for ( uint i=0; i < fileList->count(); i++ )
        {
            processLinkDir( (*fileList)[i], baseDir, destDir );
            qApp->processEvents();
        }
    }
    else
    {
        for ( int i = fileList->count()-1; i >= 0 ; i-- )
        {
            processLinkDir( (*fileList)[i], baseDir, destDir );
            qApp->processEvents();
        }
    }
 }
 void Ipkg :: processLinkDir( const QString &file, const QString &destDir, const QString &baseDir )
 {
    QString sourceFile = baseDir + file;
    
    QString linkFile = destDir;
    if ( file.startsWith( "/" ) && destDir.right( 1 ) == "/" )
    {
        linkFile += file.mid( 1 );
    }   
    else
    {
        linkFile += file;
    }
    QString text;
    if ( createLinks )
    {
        // If this file is a directory (ends with a /) and it doesn't exist,
        // we need to create it
        if ( file.right(1) == "/" )
        {
            QFileInfo f( linkFile );
            if ( !f.exists() )
            {
                emit outputText( QString( "Creating directory " ) + linkFile );
                QDir d;
                d.mkdir( linkFile, true );
            }
            else
                emit outputText( QString( "Directory " ) + linkFile + " exists" );
            
        }
        else
        {
            int rc = symlink( sourceFile, linkFile );
            text = (rc == 0 ? "Linked " : "Failed to link ");
            text += sourceFile + " to " + linkFile;
            emit outputText( text );
        }
    }
    else
    {
        QFileInfo f( linkFile );
        if ( f.exists() )
        {
            if ( f.isFile() )
            {
                QFile f( linkFile );
                bool rc = f.remove();
                text = (rc ? "Removed " : "Failed to remove ");
                text += linkFile;
                emit outputText( text );
            }
            else if ( f.isDir() )
            {
                QDir d;
                bool rc = d.rmdir( linkFile, true );
                text = (rc ? "Removed " : "Failed to remove ");
                text += linkFile;
                emit outputText( text );
            }
        }
    }
    
 }
diff --git a/noncore/settings/aqpkg/letterpushbutton.cpp b/noncore/settings/aqpkg/letterpushbutton.cpp
index afe25d8..ca96c6c 100644
--- a/noncore/settings/aqpkg/letterpushbutton.cpp
+++ b/noncore/settings/aqpkg/letterpushbutton.cpp
@@ -1,34 +1,34 @@
 /***************************************************************************
                          letterpushbutton.cpp  -  description
                             -------------------
    begin                : Wed Oct 16 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 "letterpushbutton.h"
-LetterPushButton :: LetterPushButton( const QString &text, QWidget *parent, const char *name=0 )
+LetterPushButton :: LetterPushButton( const QString &text, QWidget *parent, const char *name )
   : QPushButton( text, parent, name )
 {
   connect( this, SIGNAL(released()), this, SLOT(released_emmitor()) );
 }
 LetterPushButton :: ~LetterPushButton()
 {
 }
 void LetterPushButton :: released_emmitor()
 {
    emit released( text() );
 }
diff --git a/noncore/settings/aqpkg/mainwin.cpp b/noncore/settings/aqpkg/mainwin.cpp
index 0141359..3ddc582 100644
--- a/noncore/settings/aqpkg/mainwin.cpp
+++ b/noncore/settings/aqpkg/mainwin.cpp
@@ -1,209 +1,210 @@
 /***************************************************************************
                          mainwin.cpp  -  description
                             -------------------
    begin                : Mon Aug 26 13:32:30 BST 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 <iostream>
+using namespace std;
 #include <qmenubar.h>
 #include <qpopupmenu.h>
 #include <qmessagebox.h>
 #include "mainwin.h"
 #include "datamgr.h"
 #include "networkpkgmgr.h"
 #include "settingsimpl.h"
 #include "helpwindow.h"
 #include "utils.h"
 #include "global.h"
 MainWindow :: MainWindow( QWidget *p, char *name )
                :QMainWindow( p, name )
 {
 #ifdef QWS
    showMaximized();
 #endif
    setCaption( "AQPkg - Package Manager" );
    // Create our menu
    help = new QPopupMenu( this );
    help->insertItem( "&General", this, SLOT(displayHelp()), Qt::CTRL+Qt::Key_G );
        help->insertItem( "&About", this, SLOT(displayAbout()), Qt::CTRL+Qt::Key_A );
    settings = new QPopupMenu( this );
        settings->insertItem( "&Settings", this, SLOT(displaySettings()), Qt::CTRL+Qt::Key_S );
    edit = new QPopupMenu( this );
        edit->insertItem( "&Find", this, SLOT(searchForPackage()), Qt::CTRL+Qt::Key_I );
        edit->insertItem( "Find &Next", this, SLOT(repeatSearchForPackage()), Qt::CTRL+Qt::Key_N );
    filter = new QPopupMenu( this );
-        mnuShowUninstalledPkgsId = filter->insertItem( "Show &Uninstalled Packages", this, SLOT(filterUninstalledPackages()), Qt::CTRL+Qt::Key_U );
+        mnuShowUninstalledPkgsId = filter->insertItem( "Show &Non-Installed Packages", this, SLOT(filterUninstalledPackages()), Qt::CTRL+Qt::Key_U );
        mnuShowInstalledPkgsId = filter->insertItem( "Show In&stalled Packages", this, SLOT(filterInstalledPackages()), Qt::CTRL+Qt::Key_S );
        mnuShowUpgradedPkgsId = filter->insertItem( "Show U&pdated Packages", this, SLOT(filterUpgradedPackages()), Qt::CTRL+Qt::Key_P );
    filter->insertSeparator();
    mnuFilterByCategory = filter->insertItem( "Filter By &Category", this, SLOT(filterCategory()), Qt::CTRL+Qt::Key_C );
    mnuSetFilterCategory = filter->insertItem( "Set Filter C&ategory", this, SLOT(setFilterCategory()), Qt::CTRL+Qt::Key_A );
        // Create the main menu
        menu = menuBar();  //new QMenuBar( this );
        menu->insertItem( "&Settings", settings );
        menu->insertItem( "&Edit", edit );
        menu->insertItem( "&Filter", filter );
        menu->insertItem( "&Help", help );
    mgr = new DataManager();
    mgr->loadServers();
        stack = new QWidgetStack( this );
        networkPkgWindow = new NetworkPackageManager( mgr, stack );
        stack->addWidget( networkPkgWindow, 1 );
        setCentralWidget( stack );
        stack->raiseWidget( networkPkgWindow );
 }
 MainWindow :: ~MainWindow()
 {
        delete networkPkgWindow;
 }
 void MainWindow :: setDocument( const QString &doc )
 {
    // Remove path from package
    QString package = Utils::getPackageNameFromIpkFilename( doc );
    std::cout << "Selecting package " << package << std::endl;
    networkPkgWindow->selectLocalPackage( package );
 }
 void MainWindow :: displaySettings()
 {
    SettingsImpl *dlg = new SettingsImpl( mgr, this, "Settings", true );
    if ( dlg->showDlg( 0 ) )
            networkPkgWindow->updateData();
    delete dlg;
 }
 void MainWindow :: displayHelp()
 {
    HelpWindow *dlg = new HelpWindow( this );
    dlg->exec();
    delete dlg;
 }
 void MainWindow :: searchForPackage()
 {
    networkPkgWindow->searchForPackage( false );
 }
 void MainWindow :: repeatSearchForPackage()
 {
    networkPkgWindow->searchForPackage( true );
 }
 void MainWindow :: displayAbout()
 {
    QMessageBox::about( this, "About AQPkg", VERSION_TEXT );
 }
 void MainWindow :: filterUninstalledPackages()
 {
    bool val;
    if ( filter->isItemChecked( mnuShowUninstalledPkgsId ) )
    {
        val = false;
        filter->setItemChecked( mnuShowUninstalledPkgsId, false );
    }
    else
    {
        val = true;
        filter->setItemChecked( mnuShowUninstalledPkgsId, true );
    }
    filter->setItemChecked( mnuShowInstalledPkgsId, false );
    networkPkgWindow->showOnlyInstalledPackages( false );
    filter->setItemChecked( mnuShowUpgradedPkgsId, false );
    networkPkgWindow->showUpgradedPackages( false );
    networkPkgWindow->showOnlyUninstalledPackages( val );
 }
 void MainWindow :: filterInstalledPackages()
 {
    bool val;
    if ( filter->isItemChecked( mnuShowInstalledPkgsId ) )
    {
        val = false;
        filter->setItemChecked( mnuShowInstalledPkgsId, false );
    }
    else
    {
        val = true;
        filter->setItemChecked( mnuShowInstalledPkgsId, true );
    }
    filter->setItemChecked( mnuShowUninstalledPkgsId, false );
    networkPkgWindow->showOnlyUninstalledPackages( false );
    filter->setItemChecked( mnuShowUpgradedPkgsId, false );
    networkPkgWindow->showUpgradedPackages( false );
    networkPkgWindow->showOnlyInstalledPackages( val );
 }
 void MainWindow :: filterUpgradedPackages()
 {
    bool val;
    if ( filter->isItemChecked( mnuShowUpgradedPkgsId ) )
    {
        val = false;
        filter->setItemChecked( mnuShowUpgradedPkgsId, false );
    }
    else
    {
        val = true;
        filter->setItemChecked( mnuShowUpgradedPkgsId, true );
    }
    filter->setItemChecked( mnuShowUninstalledPkgsId, false );
    networkPkgWindow->showOnlyUninstalledPackages( false );
    filter->setItemChecked( mnuShowInstalledPkgsId, false );
    networkPkgWindow->showOnlyInstalledPackages( false );
    networkPkgWindow->showUpgradedPackages( val );
 }
 void MainWindow :: setFilterCategory()
 {
    if ( networkPkgWindow->setFilterCategory( ) )
        filter->setItemChecked( mnuFilterByCategory, true );
 }
 void MainWindow :: filterCategory()
 {
    if ( filter->isItemChecked( mnuFilterByCategory ) )
    {
        networkPkgWindow->filterByCategory( false );
        filter->setItemChecked( mnuFilterByCategory, false );
    }
    else
    {
        if ( networkPkgWindow->filterByCategory( true ) )
            filter->setItemChecked( mnuFilterByCategory, true );
    }
-}
-\ No newline at end of file
+}
diff --git a/noncore/settings/aqpkg/networkpkgmgr.cpp b/noncore/settings/aqpkg/networkpkgmgr.cpp
index d9e62b6..79a380e 100644
--- a/noncore/settings/aqpkg/networkpkgmgr.cpp
+++ b/noncore/settings/aqpkg/networkpkgmgr.cpp
@@ -1,859 +1,859 @@
 /***************************************************************************
                          networkpkgmgr.cpp  -  description
                             -------------------
    begin                : Mon Aug 26 13:32:30 BST 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 <fstream>
 #include <iostream>
 using namespace std;
 #include <unistd.h>
 #include <stdlib.h>
 #include <linux/limits.h>
 #ifdef QWS
 #include <qpe/qpeapplication.h>
 #include <qpe/qcopenvelope_qws.h>
 #include <qpe/config.h>
 #else
 #include <qapplication.h>
 #endif
 #include <qlabel.h>
 #include <qfile.h>
 #include <qmessagebox.h>
 #include "datamgr.h"
 #include "networkpkgmgr.h"
 #include "installdlgimpl.h"
 #include "ipkg.h"
 #include "inputdlg.h"
 #include "letterpushbutton.h"
 #include "categoryfilterimpl.h"
 #include "global.h"
 extern int compareVersions( const char *v1, const char *v2 );
 NetworkPackageManager::NetworkPackageManager( DataManager *dataManager, QWidget *parent, const char *name)
  : QWidget(parent, name)
 {
    dataMgr = dataManager;
 #ifdef QWS
        // read download directory from config file
        Config cfg( "aqpkg" );
        cfg.setGroup( "settings" );
        currentlySelectedServer = cfg.readEntry( "selectedServer", "local" );
        showJumpTo = cfg.readBoolEntry( "showJumpTo", "true" );
 #endif
    showUninstalledPkgs = false;
    showInstalledPkgs = false;
    showUpgradedPkgs = false;
    categoryFilterEnabled = false;
    initGui();
    setupConnections();
    updateData();
 }
 NetworkPackageManager::~NetworkPackageManager()
 {
 }
 void NetworkPackageManager :: timerEvent ( QTimerEvent * )
 {
    killTimer( timerId );
    // Add server names to listbox
    updateData();
 }
 void NetworkPackageManager :: updateData()
 {
    serversList->clear();
    packagesList->clear();
    
    vector<Server>::iterator it;
    int activeItem = -1;
    int i;
    for ( i = 0, it = dataMgr->getServerList().begin() ; it != dataMgr->getServerList().end() ; ++it, ++i )
    {
 //        cout << "Adding " << it->getServerName() << " to combobox" << endl;
        if ( !it->isServerActive() )
        {
            cout << it->getServerName() << " is not active" << endl;
            i--;
            continue;
        }
        serversList->insertItem( it->getServerName() );
        if ( it->getServerName() == currentlySelectedServer )
                activeItem = i;
        }
        // set selected server to be active server
        if ( activeItem != -1 )
                serversList->setCurrentItem( activeItem );
    serverSelected( 0 );
 }
 void NetworkPackageManager :: selectLocalPackage( const QString &pkg )
 {
    // First select local server
    for ( int i = 0 ; i < serversList->count() ; ++i )
    {
        if ( serversList->text( i ) == LOCAL_IPKGS )
        {
            serversList->setCurrentItem( i );
            break;
        }
    }
    serverSelected( 0 );
    // Now set the check box of the selected package
    for ( QCheckListItem *item = (QCheckListItem *)packagesList->firstChild();
          item != 0 ;
          item = (QCheckListItem *)item->nextSibling() )
    {
        if ( item->text().startsWith( pkg ) )
        {
            item->setOn( true );
            break;
        }
    }
 }
 void NetworkPackageManager :: initGui()
 {
    QLabel *l = new QLabel( "Servers", this );
    serversList = new QComboBox( this );
    packagesList = new QListView( this );
    update = new QPushButton( "Refresh Lists", this );
    download = new QPushButton( "Download", this );
    upgrade = new QPushButton( "Upgrade", this );
    apply = new QPushButton( "Apply", this );
    QVBoxLayout *vbox = new QVBoxLayout( this, 0, -1, "VBox" );
    QHBoxLayout *hbox1 = new QHBoxLayout( vbox, -1, "HBox1" );
    hbox1->addWidget( l );
    hbox1->addWidget( serversList );
    QHBoxLayout *hbox3 = new QHBoxLayout( vbox, -1, "HBox1" );
    QHBoxLayout *hbox4 = new QHBoxLayout( vbox, -1, "HBox1" );
    if ( showJumpTo )
    {    
        char text[2];
        text[1] = '\0';
        for ( int i = 0 ; i < 26 ; ++i )
        {
                text[0] = 'A' + i;
                LetterPushButton *b = new LetterPushButton( text, this );
                connect( b, SIGNAL( released( QString ) ), this, SLOT( letterPushed( QString ) ) );
                if ( i < 13 )
                hbox3->addWidget( b );
                else
                hbox4->addWidget( b );
        }
    }
    vbox->addWidget( packagesList );
    packagesList->addColumn( "Packages" );
    QHBoxLayout *hbox2 = new QHBoxLayout( vbox, -1, "HBox2" );
    hbox2->addWidget( update );
    hbox2->addWidget( download );
    hbox2->addWidget( upgrade );
    hbox2->addWidget( apply );
 }
 void NetworkPackageManager :: setupConnections()
 {
    connect( serversList, SIGNAL(activated( int )), this, SLOT(serverSelected( int )));
    connect( apply, SIGNAL(released()), this, SLOT(applyChanges()) );
    connect( download, SIGNAL(released()), this, SLOT(downloadPackage()) );
    connect( upgrade, SIGNAL( released()), this, SLOT(upgradePackages()) );
    connect( update, SIGNAL(released()), this, SLOT(updateServer()) );
 }
 void NetworkPackageManager :: showProgressDialog( char *initialText )
 {
    if ( !progressDlg )
        progressDlg = new ProgressDlg( this, "Progress", false );
    progressDlg->setText( initialText );
    progressDlg->show();
 }
 void NetworkPackageManager :: serverSelected( int )
 {
    packagesList->clear();
    // display packages
    QString serverName = serversList->currentText();
    currentlySelectedServer = serverName;
 #ifdef QWS
        // read download directory from config file
        Config cfg( "aqpkg" );
        cfg.setGroup( "settings" );
        cfg.writeEntry( "selectedServer", currentlySelectedServer );
 #endif
-    Server *s = dataMgr->getServer( serverName );
+    vector<Server>::iterator s = dataMgr->getServer( serverName );
    vector<Package> &list = s->getPackageList();
    vector<Package>::iterator it;
    for ( it = list.begin() ; it != list.end() ; ++it )
    {
        QString text = "";
        // Apply show only uninstalled packages filter
        if ( showUninstalledPkgs && it->isInstalled() )
            continue;
        // Apply show only installed packages filter
        if ( showInstalledPkgs && !it->isInstalled() )
            continue;
        // Apply show only new installed packages filter
        if ( showUpgradedPkgs )
        {
            if ( !it->isInstalled() ||
                 compareVersions( it->getInstalledVersion(), it->getVersion() ) != 1 )
                continue;
        }
        // Apply the section filter
        if ( categoryFilterEnabled && categoryFilter != "" )
        {
            if ( it->getSection() == "" || categoryFilter.find( it->getSection().lower() ) == -1 )
                continue;
        }
        // If the local server, only display installed packages
        if ( serverName == LOCAL_SERVER && !it->isInstalled() )
            continue;
        text += it->getPackageName();
        if ( it->isInstalled() )
        {
            text += " (installed)";
            // If a different version of package is available, postfix it with an *
            if ( it->getVersion() != it->getInstalledVersion() )
            {
                if ( compareVersions( it->getInstalledVersion(), it->getVersion() ) == 1 )
                    text += "*";
            }
        }
        QCheckListItem *item = new QCheckListItem( packagesList, text, QCheckListItem::CheckBox );
        if ( it->isInstalled() )
        {
            QString destName = "";
            if ( it->getLocalPackage() )
            {
                if ( it->getLocalPackage()->getInstalledTo() )
                    destName = it->getLocalPackage()->getInstalledTo()->getDestinationName();
            }
            else
            {
                if ( it->getInstalledTo() )
                    destName = it->getInstalledTo()->getDestinationName();
            }
            if ( destName != "" )
                new QCheckListItem( item, QString( "Installed To - " ) + destName );
        }
        
        if ( !it->isPackageStoredLocally() )
        {
            new QCheckListItem( item, QString( "Description - " ) + it->getDescription() );
            new QCheckListItem( item, QString( "Size - " ) + it->getPackageSize() );
            new QCheckListItem( item, QString( "Section - " ) + it->getSection() );
        }
        else
            new QCheckListItem( item, QString( "Filename - " ) + it->getFilename() );
        
                if ( serverName == LOCAL_SERVER )
                {
                new QCheckListItem( item, QString( "V. Installed - " ) + it->getVersion() );
                }
                else
                {
                new QCheckListItem( item, QString( "V. Available - " ) + it->getVersion() );
                if ( it->getLocalPackage() )
                {
                                if ( it->isInstalled() )
                            new QCheckListItem( item, QString( "V. Installed - " ) + it->getInstalledVersion() );
                        }
                }
        packagesList->insertItem( item );
    }
    // If the local server or the local ipkgs server disable the download button
    if ( serverName == LOCAL_SERVER )
    {
        upgrade->setEnabled( false );
        download->setText( "Download" );
        download->setEnabled( true );
    }
    else if ( serverName == LOCAL_IPKGS )
    {
        upgrade->setEnabled( false );
        download->setEnabled( true );
        download->setText( "Remove" );
    }
    else
    {
        upgrade->setEnabled( true );
        download->setEnabled( true );
        download->setText( "Download" );
    }
 }
 void NetworkPackageManager :: updateServer()
 {
    QString serverName = serversList->currentText();
    // Update the current server
    // Display dialog
    // Disable buttons to stop silly people clicking lots on them :)
    // First, write out ipkg_conf file so that ipkg can use it
    dataMgr->writeOutIpkgConf();
    Ipkg ipkg;
    ipkg.setOption( "update" );
    InstallDlgImpl dlg( &ipkg, "Refreshing server package lists", this, "Upgrade", true );
    dlg.showDlg();
    // Reload data
    dataMgr->reloadServerData();
    serverSelected(-1);
 //  delete progDlg;
 }
 void NetworkPackageManager :: upgradePackages()
 {
    // We're gonna do an upgrade of all packages
    // First warn user that this isn't recommended
    QString text = "WARNING: Upgrading while\nOpie/Qtopia is running\nis NOT recommended!\n\nAre you sure?\n";
    QMessageBox warn("Warning", text, QMessageBox::Warning,
                        QMessageBox::Yes,
                        QMessageBox::No | QMessageBox::Escape | QMessageBox::Default ,
                        0, this );
    warn.adjustSize();
                        
    if ( warn.exec() == QMessageBox::Yes )
    {
        // First, write out ipkg_conf file so that ipkg can use it
        dataMgr->writeOutIpkgConf();
        // Now run upgrade
        Ipkg ipkg;
        ipkg.setOption( "upgrade" );
        
        InstallDlgImpl dlg( &ipkg, "Upgrading installed packages", this, "Upgrade", true );
        dlg.showDlg();
        // Reload data
        dataMgr->reloadServerData();
        serverSelected(-1);
    }
 }
 void NetworkPackageManager :: downloadPackage()
 {
    bool doUpdate = true;
    if ( download->text() == "Download" )
    {
        // See if any packages are selected
        bool found = false;
        if ( serversList->currentText() != LOCAL_SERVER )
        {
            for ( QCheckListItem *item = (QCheckListItem *)packagesList->firstChild();
                  item != 0 && !found;
                  item = (QCheckListItem *)item->nextSibling() )
            {
                if ( item->isOn() )
                    found = true;
            }
        }
        
        // If user selected some packages then download the and store the locally
        // otherwise, display dialog asking user what package to download from an http server
        // and whether to install it
        if ( found )
            downloadSelectedPackages();
        else
            downloadRemotePackage();
        
    }
    else if ( download->text() == "Remove" )
    {
        doUpdate = false;
        for ( QCheckListItem *item = (QCheckListItem *)packagesList->firstChild();
              item != 0 ;
              item = (QCheckListItem *)item->nextSibling() )
        {
            if ( item->isOn() )
            {
                QString name = item->text();
                int pos = name.find( "*" );
                name.truncate( pos );
                // if (there is a (installed), remove it
                pos = name.find( "(installed)" );
                if ( pos > 0 )
                    name.truncate( pos - 1 );
               
                Package *p = dataMgr->getServer( serversList->currentText() )->getPackage( name );
                QString msgtext;
                msgtext.sprintf( "Are you sure you wish to delete\n%s?", (const char *)p->getPackageName() );
                if ( QMessageBox::information( this, "Are you sure?",
                                    msgtext, "No", "Yes" ) == 1 )
                {
                    doUpdate = true;
                    QFile f( p->getFilename() );
                    f.remove();
                }
            }
        }
    }
    if ( doUpdate )
    {
        dataMgr->reloadServerData();
        serverSelected( -1 );
    }
 }
 void NetworkPackageManager :: downloadSelectedPackages()
 {
    // First, write out ipkg_conf file so that ipkg can use it
    dataMgr->writeOutIpkgConf();
    // Display dialog to user asking where to download the files to
    bool ok = FALSE;
    QString dir = "";
 #ifdef QWS
    // read download directory from config file
    Config cfg( "aqpkg" );
    cfg.setGroup( "settings" );
    dir = cfg.readEntry( "downloadDir", "/home/root/Documents/application/ipkg" );
 #endif
    QString text = InputDialog::getText( tr( "Download to where" ), tr( "Enter path to download to" ), dir, &ok, this );
    if ( ok && !text.isEmpty() )
        dir = text;   // user entered something and pressed ok
    else
        return; // user entered nothing or pressed cancel
 #ifdef QWS
    // Store download directory in config file
    cfg.writeEntry( "downloadDir", dir );
 #endif
    // Get starting directory
    char initDir[PATH_MAX];
    getcwd( initDir, PATH_MAX );
    // Download each package
    Ipkg ipkg;
    connect( &ipkg, SIGNAL(outputText(const QString &)), this, SLOT(displayText(const QString &)));
    ipkg.setOption( "download" );
    ipkg.setRuntimeDirectory( dir );
    for ( QCheckListItem *item = (QCheckListItem *)packagesList->firstChild();
          item != 0 ;
          item = (QCheckListItem *)item->nextSibling() )
    {
        if ( item->isOn() )
        {
            QString name = item->text();
            int pos = name.find( "*" );
            name.truncate( pos );
            // if (there is a (installed), remove it
            pos = name.find( "(installed)" );
            if ( pos > 0 )
                name.truncate( pos - 1 );
            ipkg.setPackage( name );
            ipkg.runIpkg( );
        }
    }
 }
 void NetworkPackageManager :: downloadRemotePackage()
 {
    // Display dialog
    bool ok;
    QString package = InputDialog::getText( "Install Remote Package", tr( "Enter package location" ), "http://", &ok, this );
    if ( !ok || package.isEmpty() )
        return;
 //    DownloadRemoteDlgImpl dlg( this, "Install", true );
 //    if ( dlg.exec() == QDialog::Rejected )
 //        return;
    // grab details from dialog
 //    QString package = dlg.getPackageLocation();
    InstallData item;
    item.option = "I";
    item.packageName = package;
    vector<InstallData> workingPackages;
    workingPackages.push_back( item );
    InstallDlgImpl dlg2( workingPackages, dataMgr, this, "Install", true );
    dlg2.showDlg();
    // Reload data
    dataMgr->reloadServerData();
    serverSelected(-1);
 #ifdef QWS
    // Finally let the main system update itself
    QCopEnvelope e("QPE/System", "linkChanged(QString)");
    QString lf = QString::null;
    e << lf;
 #endif
 }
 void NetworkPackageManager :: applyChanges()
 {
    stickyOption = "";
    
    // First, write out ipkg_conf file so that ipkg can use it
    dataMgr->writeOutIpkgConf();
    // Now for each selected item
    // deal with it
    vector<InstallData> workingPackages;
    for ( QCheckListItem *item = (QCheckListItem *)packagesList->firstChild();
          item != 0 ;
          item = (QCheckListItem *)item->nextSibling() )
    {
        if ( item->isOn() )
        {
            InstallData data = dealWithItem( item );
            workingPackages.push_back( data );
                }
    }
    if ( workingPackages.size() == 0 )
    {
        // Nothing to do
        QMessageBox::information( this, "Nothing to do",
                             "No packages selected", "OK" );
        
        return;
    }
    
    // do the stuff
    InstallDlgImpl dlg( workingPackages, dataMgr, this, "Install", true );
    dlg.showDlg();
    // Reload data
    dataMgr->reloadServerData();
    serverSelected(-1);
 #ifdef QWS
    // Finally let the main system update itself
    QCopEnvelope e("QPE/System", "linkChanged(QString)");
    QString lf = QString::null;
    e << lf;
 #endif
 }
 // decide what to do - either remove, upgrade or install
 // Current rules:
 //    If not installed - install
 //    If installed and different version available - upgrade
 //    If installed and version up to date - remove
 InstallData NetworkPackageManager :: dealWithItem( QCheckListItem *item )
 {
    QString name = item->text();
    int pos = name.find( "*" );
    name.truncate( pos );
    // if (there is a (installed), remove it
    pos = name.find( "(installed)" );
    if ( pos > 0 )
        name.truncate( pos - 1 );
    // Get package
-    Server *s = dataMgr->getServer( serversList->currentText() );
+    vector<Server>::iterator s = dataMgr->getServer( serversList->currentText() );
    Package *p = s->getPackage( name );
    // If the package has a filename then it is a local file
    if ( p->isPackageStoredLocally() )
        name = p->getFilename();
    QString option;
    QString dest = "root";
    if ( !p->isInstalled() )
    {
        InstallData item;
        item.option = "I";
        item.packageName = name;
        return item;
    }
    else
    {
        InstallData item;
        item.option = "D";
        if ( !p->isPackageStoredLocally() )
            item.packageName = p->getInstalledPackageName();
        else
            item.packageName = name;
        
        if ( p->getInstalledTo() )
        {
            item.destination = p->getInstalledTo();
            cout << "dest - " << p->getInstalledTo()->getDestinationName() << endl;
            cout << "dest - " << p->getInstalledTo()->getDestinationPath() << endl;
        }
        else
        {
            item.destination = p->getLocalPackage()->getInstalledTo();
        }
        // Now see if version is newer or not
        int val = compareVersions( p->getInstalledVersion(), p->getVersion() );
        // If the version requested is older and user selected a local ipk file, then reinstall the file
        if ( p->isPackageStoredLocally() && val == -1 )
            val = 0;
            
        if ( val == -2 )
        {
            // Error - should handle
        }
        else if ( val == -1 )
        {
            // Version available is older - remove only
            item.option = "D";
        }
        else
        {
            QString caption;
            QString text;
            QString secondButton;
            QString secondOption;
            if ( val == 0 )
            {
                // Version available is the same - option to remove or reinstall
                caption = "Do you wish to remove or reinstall\n%s?";
                text = "Remove or ReInstall";
                secondButton = "ReInstall";
                secondOption = "R";
            }
            else if ( val == 1 )
            {
                // Version available is newer - option to remove or upgrade
                caption = "Do you wish to remove or upgrade\n%s?";
                text = "Remove or Upgrade";
                secondButton = "Upgrade";
                secondOption = "U";
            }
            // Sticky option not implemented yet, but will eventually allow
            // the user to say something like 'remove all'
            if ( stickyOption == "" )
            {
                QString msgtext;
                msgtext.sprintf( caption, (const char *)name );
                switch( QMessageBox::information( this, text,
                                    msgtext, "Remove", secondButton ) )
                {
                    case 0: // Try again or Enter
                        // option 0 = Remove
                        item.option = "D";
                        break;
                    case 1: // Quit or Escape
                        item.option = secondOption;
                        break;
                }
            }
            else
            {
 //                item.option = stickyOption;
            }
        }
        
        // Check if we are reinstalling the same version
        if ( item.option != "R" )
           item.recreateLinks = true;
        else
           item.recreateLinks = false;
        // User hit cancel (on dlg - assume remove)
        return item;
    }
 }
 void NetworkPackageManager :: displayText( const QString &t )
 {
    cout << t << endl;
 }
 void NetworkPackageManager :: letterPushed( QString t )
 {
    QCheckListItem *top = (QCheckListItem *)packagesList->firstChild();
    QCheckListItem *start = (QCheckListItem *)packagesList->currentItem();
    if ( packagesList->firstChild() == 0 )
        return;
    QCheckListItem *item;
    if ( start == 0 )
    {
        item = (QCheckListItem *)packagesList->firstChild();
        start = top;
    }
    else
        item = (QCheckListItem *)start->nextSibling();
    if ( item == 0 )
        item = (QCheckListItem *)packagesList->firstChild();
    do
    {
        if ( item->text().lower().startsWith( t.lower() ) )
        {
            packagesList->setSelected( item, true );
            packagesList->ensureItemVisible( item );
            break;
        }
        item = (QCheckListItem *)item->nextSibling();
        if ( !item )
            item = (QCheckListItem *)packagesList->firstChild();        
    } while ( item != start);
 }
 void NetworkPackageManager :: searchForPackage( bool findNext )
 {
    bool ok = false;
    if ( !findNext || lastSearchText.isEmpty() )
        lastSearchText = InputDialog::getText( "Search for package", "Enter package to search for", lastSearchText, &ok, this ).lower();
    else
        ok = true;
        
    if ( ok && !lastSearchText.isEmpty() )
    {
        cout << "searching for " << lastSearchText << endl;
        // look through package list for text startng at current position
        vector<InstallData> workingPackages;
        QCheckListItem *start = (QCheckListItem *)packagesList->currentItem();
        if ( start != 0 )
            start = (QCheckListItem *)start->nextSibling();
        
        if ( start == 0 )
            start = (QCheckListItem *)packagesList->firstChild();
        
        for ( QCheckListItem *item = start; item != 0 ;
              item = (QCheckListItem *)item->nextSibling() )
        {
            cout << "checking " << item->text().lower() << endl;
            if ( item->text().lower().find( lastSearchText ) != -1 )
            {
                cout << "matched " << item->text() << endl;
                packagesList->ensureItemVisible( item );
                packagesList->setCurrentItem( item );
                break;
            }
        }   
    }
 }
 void NetworkPackageManager :: showOnlyUninstalledPackages( bool val )
 {
    showUninstalledPkgs = val;
    serverSelected( -1 );
 }
 void NetworkPackageManager :: showOnlyInstalledPackages( bool val )
 {
    showInstalledPkgs = val;
    serverSelected( -1 );
 }
 void NetworkPackageManager :: showUpgradedPackages( bool val )
 {
    showUpgradedPkgs = val;
    serverSelected( -1 );
 }
 bool NetworkPackageManager :: filterByCategory( bool val )
 {
    if ( val )
    {
        if ( categoryFilter == "" )
        {
            if ( !setFilterCategory() )
                return false;
        }
            
        categoryFilterEnabled = true;
        serverSelected( -1 );
        return true;
    }
    else
    {
        // Turn off filter
        categoryFilterEnabled = false;
        serverSelected( -1 );
        return false;
    }
 }
 bool NetworkPackageManager :: setFilterCategory( )
 {
    // Get categories;
    CategoryFilterImpl dlg( DataManager::getAvailableCategories(), categoryFilter, this );
    if ( dlg.exec() == QDialog::Accepted )
    {
        categoryFilter = dlg.getSelectedFilter();
        if ( categoryFilter == "" )
            return false;
            
        categoryFilterEnabled = true;
        serverSelected( -1 );
        return true;
    }
    return false;
 }
diff --git a/noncore/settings/aqpkg/server.cpp b/noncore/settings/aqpkg/server.cpp
index 58407d5..2cb0533 100644
--- a/noncore/settings/aqpkg/server.cpp
+++ b/noncore/settings/aqpkg/server.cpp
@@ -1,307 +1,307 @@
 /***************************************************************************
                          server.cpp  -  description
                             -------------------
    begin                : Mon Aug 26 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
    description          : This class holds details about a server
                         : e.g. all the packages that contained on the server
                         :      the installation status
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   This program is free software; you can redistribute it and/or modify  *
 *   it under the terms of the GNU General Public License as published by  *
 *   the Free Software Foundation; either version 2 of the License, or     *
 *   (at your option) any later version.                                   *
 *                                                                         *
 ***************************************************************************/
 #include <stdio.h>
 #include <string.h>
 #include <stdlib.h>
 #include <iostream>
 #include <fstream>
 using namespace std;
 #include "server.h"
 #include "datamgr.h"
 #ifdef QWS
 #include <qpe/global.h>
 #include <qpe/applnk.h>
 #include <qlist.h>
 #endif
 #include "utils.h"
 #include "global.h"
 Server :: Server( const char *name, const char *url )
 {
    serverName = name;
    serverUrl = url;
    packageFile = IPKG_DIR;
    active = true;
    packageFile += "lists/" + serverName;
 }
 Server :: ~Server()
 {
        cleanUp();
 }
 void Server :: cleanUp()
 {
    packageList.clear();
 }
 void Server :: readStatusFile(  vector<Destination> &destList )
 {
    cleanUp();
    vector<Destination>::iterator dit;
    bool rootRead = false;
    for ( dit = destList.begin() ; dit != destList.end() ; ++dit )
    {
        bool installingToRoot = false;
        
        QString path = dit->getDestinationPath();
        if ( path.right( 1 ) != "/" )
            path += "/";
            
        if ( path == "/" )
        {
            rootRead = true;
            installingToRoot = true;
        }   
        
        packageFile = path + "usr/lib/ipkg/status";
-        readPackageFile( 0, false, installingToRoot, dit );
+        readPackageFile( 0, false, installingToRoot, &( *dit ) );
    }
    // Ensure that the root status file is read
    if ( !rootRead )
    {
        cout << "Reading status file " << "/usr/lib/ipkg/status" << endl;
        packageFile = "/usr/lib/ipkg/status";
        readPackageFile( 0, false, true );
    }
 }
 void Server :: readLocalIpks( Server *local )
 {
    cleanUp();
 #ifdef QWS
    // First, get any local IPKGs in the documents area
    // Only applicable to Qtopie/Opie
        DocLnkSet files;
        Global::findDocuments( &files, "application/ipkg" );
        // Now add the items to the list
        QListIterator<DocLnk> it( files.children() );
        for ( ; it.current() ; ++it )
        {
        // OK, we have a local IPK file, I think the standard naming conventions
        // for these are packagename_version_arm.ipk
        QString file = (*it)->file();
        // Changed to display the filename (excluding the path)
        QString packageName = Utils::getFilenameFromIpkFilename( file );
        QString ver = Utils::getPackageVersionFromIpkFilename( file );
        packageList.push_back( Package( packageName ) );
        packageList.back().setVersion( ver );
        packageList.back().setFilename( file );
        packageList.back().setPackageStoredLocally( true );
        
        }
 #else
        QString names[] = { "advancedfm_0.9.1-20020811_arm.ipk", "libopie_0.9.1-20020811_arm.ipk", "libopieobex_0.9.1-20020811.1_arm.ipk", "opie-addressbook_0.9.1-20020811_arm.ipk" };
        for ( int i = 0 ; i < 4 ; ++i )
        {
                // OK, we have a local IPK file, I think the standard naming conventions
                // for these are packagename_version_arm.ipk
                QString file = names[i];
                int p = file.find( "_" );
                QString tmp = file.mid( 0, p );
                packageList.push_back( Package( tmp ) );
                int p2 = file.find( "_", p+1 );
                tmp = file.mid( p+1, p2-(p+1) );
                packageList.back().setVersion( tmp );
                packageList.back().setPackageStoredLocally( true );
        }
 #endif
    // build local packages
    buildLocalPackages( local );
 }
 void Server :: readPackageFile( Server *local, bool clearAll, bool installingToRoot, Destination *dest )
 {
    ifstream in( packageFile );
        if ( !in.is_open() )
        return;
    char line[1001];
    char k[21];
    char v[1001];
    QString key;
    QString value;
    if ( clearAll )
        cleanUp();
    Package *currPackage = 0;
    bool newPackage = true;
    do
    {
        in.getline( line, 1000 );
        if ( in.eof() )
            continue;
        k[0] = '\0';
        v[0] = '\0';
        sscanf( line, "%[^:]: %[^\n]", k, v );
        key = k;
        value = v;
        key = key.stripWhiteSpace();
        value = value.stripWhiteSpace();
        if ( key == "Package" && newPackage )
        {
            newPackage = false;
            currPackage = getPackage( value );
            if ( !currPackage )
            {
                        packageList.push_back( Package( value ) );
                        currPackage = &(packageList.back());
                currPackage->setInstalledTo( dest );
                if ( installingToRoot )
                    currPackage->setInstalledToRoot( true );
            }
            else
            {
                if (currPackage->getStatus().find( "deinstall" ) != -1 )
                    currPackage->setInstalledTo( dest );
            }
        }
        else if ( key == "Version" )
        {
            if ( currPackage )
                currPackage->setVersion( value );
        }
        else if ( key == "Status" )
        {
            if ( currPackage )
                currPackage->setStatus( value );
        }
        else if ( key == "Description" )
        {
            if ( currPackage )
                currPackage->setDescription( value );
        }
        else if ( key == "Filename" )
        {
            if ( currPackage )
                currPackage->setFilename( value );
        }
        else if ( key == "Size" )
        {
            if ( currPackage )
                currPackage->setPackageSize( value );
        }
        else if ( key == "Section" )
        {
            if ( currPackage )
                currPackage->setSection( value );
            DataManager::setAvailableCategories( value );
        }
        else if ( key == "" )
        {
            newPackage = true;
        }
    } while ( !in.eof() );
    in.close();
    // build local packages
    buildLocalPackages( local );
 }
 void Server :: buildLocalPackages( Server *local )
 {
    for ( unsigned int i = 0 ; i < packageList.size() ; ++i )
    {
                QString name = packageList[i].getPackageName();
        // If the package name is an ipk name, then convert the filename to a package name
        if ( name.find( ".ipk" ) != -1 )
            name = Utils::getPackageNameFromIpkFilename( packageList[i].getFilename() );
        if ( local )
        {
            Package *p = local->getPackage( name );
            packageList[i].setLocalPackage( p );
            if ( p )
            {
                // Set some default stuff like size and things
                if ( p->getInstalledVersion() == packageList[i].getVersion() )
                {
                    p->setPackageSize( packageList[i].getPackageSize() );
                    p->setSection( packageList[i].getSection() );
                    p->setDescription( packageList[i].getDescription() );
                }
            }
            
        }
        else
            packageList[i].setLocalPackage( 0 );
    }
 }
 Package *Server :: getPackage( QString &name )
 {
    return getPackage( (const char *)name );
 }
 Package *Server :: getPackage( const char *name )
 {
    Package *ret = 0;
    for ( unsigned int i = 0 ; i < packageList.size() && ret == 0; ++i )
    {
                if ( packageList[i].getPackageName() == name )
                        ret = &packageList[i];
        }
    return ret;
 }
 QString Server :: toString()
 {
    QString ret = "Server\n   name - " + serverName +
                       "\n   url - " + serverUrl +
                       "\n";
    for ( unsigned int i = 0 ; i < packageList.size() ; ++i )
        ret += "\n   " + packageList[i].toString();
    return ret;
 }
 vector<Package> &Server::getPackageList()
 {
    return packageList;
 }
diff --git a/noncore/settings/aqpkg/settingsimpl.cpp b/noncore/settings/aqpkg/settingsimpl.cpp
index a18a178..9dd2206 100644
--- a/noncore/settings/aqpkg/settingsimpl.cpp
+++ b/noncore/settings/aqpkg/settingsimpl.cpp
@@ -1,245 +1,246 @@
 /***************************************************************************
                          settingsimpl.cpp  -  description
                             -------------------
    begin                : Thu Aug 29 2002
    copyright            : (C) 2002 by Andy Qua
    email                : andy.qua@blueyonder.co.uk
 ***************************************************************************/
 /***************************************************************************
 *                                                                         *
 *   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 <fstream>
+#include <algorithm>
 using namespace std;
 #include <qlistbox.h>
 #include <qlineedit.h>
 #include <qpushbutton.h>
 #include <qtabwidget.h>
 #include <qcheckbox.h>
 #ifdef QWS
 #include <qpe/config.h>
 #endif
 #include "settingsimpl.h"
 #include "global.h"
 SettingsImpl :: SettingsImpl( DataManager *dataManager, QWidget * parent, const char* name, bool modal, WFlags fl )
    : SettingsBase( parent, name, modal, fl )
 {
    dataMgr = dataManager;
    setupData();
    changed = false;
    newserver = false;
    newdestination = false;
 }
 SettingsImpl :: ~SettingsImpl()
 {
 }
 bool SettingsImpl :: showDlg( int i )
 {
        TabWidget->setCurrentPage( i );
        showMaximized();
        exec();
        if ( changed )
                dataMgr->writeOutIpkgConf();
        return changed;
 }
 void SettingsImpl :: setupData()
 {
    // add servers
    vector<Server>::iterator it;
    for ( it = dataMgr->getServerList().begin() ; it != dataMgr->getServerList().end() ; ++it )
        {
        if ( it->getServerName() == LOCAL_SERVER || it->getServerName() == LOCAL_IPKGS )
            continue;
        servers->insertItem( it->getServerName() );
        }
    // add destinations
    vector<Destination>::iterator it2;
    for ( it2 = dataMgr->getDestinationList().begin() ; it2 != dataMgr->getDestinationList().end() ; ++it2 )
        destinations->insertItem( it2->getDestinationName() );
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "settings" );
    jumpTo->setChecked( cfg.readBoolEntry( "showJumpTo", "true" ) );
 #else
    jumpTo->setChecked( true );
 #endif
 }
 //------------------ Servers tab ----------------------
 void SettingsImpl :: editServer( int sel )
 {
        currentSelectedServer = sel;
-    Server *s = dataMgr->getServer( servers->currentText() );
+    vector<Server>::iterator s = dataMgr->getServer( servers->currentText() );
    serverName = s->getServerName();
    servername->setText( s->getServerName() );
    serverurl->setText( s->getServerUrl() );
    active->setChecked( s->isServerActive() );
 }
 void SettingsImpl :: newServer()
 {
        newserver = true;
        servername->setText( "" );
        serverurl->setText( "" );
        servername->setFocus();
    active->setChecked( true );
 }
 void SettingsImpl :: removeServer()
 {
-        changed = true;
+    changed = true;
-    Server *s = dataMgr->getServer( servers->currentText() );
+    vector<Server>::iterator s = dataMgr->getServer( servers->currentText() );
-        dataMgr->getServerList().erase( s );
+    dataMgr->getServerList().erase( s );
-        servers->removeItem( currentSelectedServer );
+    servers->removeItem( currentSelectedServer );
 }
 void SettingsImpl :: changeServerDetails()
 {
        changed = true;
        QString newName = servername->text();
        if ( !newserver )
        {
-                Server *s = dataMgr->getServer( serverName );
+                vector<Server>::iterator s = dataMgr->getServer( servers->currentText() );
                // Update url
                s->setServerUrl( serverurl->text() );
        s->setActive( active->isChecked() );
                // Check if server name has changed, if it has then we need to replace the key in the map
                if ( serverName != newName )
                {
                        // Update server name
                        s->setServerName( newName );
                        // See if this server is the active server
        //              if ( dataMgr->getActiveServer() == serverName )
        //                      dataMgr->setActiveServer( newName );
                        // Update list box
                        servers->changeItem( newName, currentSelectedServer );
                }
        }
        else
        {
        Server s( newName, serverurl->text() );
        dataMgr->getServerList().push_back( Server( newName, serverurl->text() ) );
        dataMgr->getServerList().end()->setActive( active->isChecked() );
                servers->insertItem( newName );
                servers->setCurrentItem( servers->count() );
                newserver = false;
        }
 }
 //------------------ Destinations tab ----------------------
 void SettingsImpl :: editDestination( int sel )
 {
        currentSelectedDestination = sel;
-    Destination *d = dataMgr->getDestination( destinations->currentText() );
+    vector<Destination>::iterator d = dataMgr->getDestination( destinations->currentText() );
    destinationName = d->getDestinationName();
    destinationname->setText( d->getDestinationName() );
    destinationurl->setText( d->getDestinationPath() );
    linkToRoot->setChecked( d->linkToRoot() );
 }
 void SettingsImpl :: newDestination()
 {
        newdestination = true;
        destinationname->setText( "" );
        destinationurl->setText( "" );
        destinationname->setFocus();
    linkToRoot->setChecked( true );
 }
 void SettingsImpl :: removeDestination()
 {
-        changed = true;
+    changed = true;
-    Destination *d = dataMgr->getDestination( destinations->currentText() );
+    vector<Destination>::iterator d = dataMgr->getDestination( destinations->currentText() );
-        dataMgr->getDestinationList().erase( d );
+    dataMgr->getDestinationList().erase( d );
        destinations->removeItem( currentSelectedDestination );
 }
 void SettingsImpl :: changeDestinationDetails()
 {
        changed = true;
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "destinations" );
 #endif
    QString newName = destinationname->text();
        if ( !newdestination )
        {
-                Destination *d = dataMgr->getDestination( destinationName );
+                vector<Destination>::iterator d = dataMgr->getDestination( destinations->currentText() );
                // Update url
                d->setDestinationPath( destinationurl->text() );
        d->linkToRoot( linkToRoot->isChecked() );
                // Check if server name has changed, if it has then we need to replace the key in the map
                if ( destinationName != newName )
                {
                        // Update server name
                        d->setDestinationName( newName );
                        // Update list box
                        destinations->changeItem( newName, currentSelectedDestination );
                }
 #ifdef QWS
        QString key = newName;
        key += "_linkToRoot";
        int val = d->linkToRoot();
        cfg.writeEntry( key, val );
 #endif        
        }
        else
        {
                dataMgr->getDestinationList().push_back( Destination( newName, destinationurl->text() ) );
                destinations->insertItem( newName );
                destinations->setCurrentItem( destinations->count() );
                newdestination = false;
 #ifdef QWS
        QString key = newName;
        key += "_linkToRoot";
        cfg.writeEntry( key, true );
 #endif
        }
 }
 //------------------ General tab ----------------------
 void SettingsImpl :: toggleJumpTo( bool val )
 {
 #ifdef QWS
    Config cfg( "aqpkg" );
    cfg.setGroup( "settings" );
    cfg.writeEntry( "showJumpTo", val );
 #endif
 }
author	andyq <andyq>	2002-11-21 20:16:40 (UTC)
committer	andyq <andyq>	2002-11-21 20:16:40 (UTC)
commit	2185394da06d32a3655e71ec022da202477350e7 (patch) (unidiff)
tree	b266ddecaa44a1fef5229bb0525c990d5e7cc51a
parent	6d302b82aab909da59852d99a31bcc7726ba9f34 (diff)
download	opie-2185394da06d32a3655e71ec022da202477350e7.zip opie-2185394da06d32a3655e71ec022da202477350e7.tar.gz opie-2185394da06d32a3655e71ec022da202477350e7.tar.bz2