/*
** Copyright (C) 1999,2000 Toivo Pedaste <toivo@ucs.uwa.edu.au>
**
*/
/*
** 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.
**
** 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 General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program in a file called COPYING; if not, write to
** the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
** MA 02110-1301, USA.
*/
/*
** Bug reports and questions can be sent to kde-devel@kde.org
*/
#include <tdelocale.h>
#include <tdeglobal.h>
#include <kdebug.h>
#include <kiconloader.h>
#include "kpackage.h"
#include "pkgInterface.h"
#include "options.h"
#include "cache.h"
#include "updateLoc.h"
#include "tdeio.h"
extern Opts *opts;
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
param::param(const TQString &nameP, bool initP, bool invertP, const TQString &flagP)
{
name = nameP;
init = initP;
invert = invertP;
flag = flagP;
flagA = "";
}
param::param(const TQString &nameP, bool initP, bool invertP, const TQString &flagP, const TQString &flagAP )
{
name = nameP;
init = initP;
invert = invertP;
flag = flagP;
flagA = flagAP;
}
param::~param()
{
}
//////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////
pkgInterface::pkgInterface( ) : TQObject(), new_pict(), updated_pict()
{
packageLoc = 0;
DELMSG = i18n("'Delete this window to continue'");
folder = SmallIcon("folder");
markInst = UserIcon("tick");
markUnInst = UserIcon("noball");
bad_pict = UserIcon("dbad");
hasRemote = FALSE;
defaultHandle = 1;
noFetch = FALSE;
hasSearchAll = FALSE;
}
//////////////////////////////////////////////////////////////////////////////
pkgInterface::~pkgInterface()
{
// if (locatedialog)
// delete locatedialog;
// if (packageLoc)
// delete packageLoc;
}
//////////////////////////////////////////////////////////////////////////////
void pkgInterface::makeMenu(TDEActionCollection *)
{
}
void pkgInterface::setMenu(TDEActionCollection*, bool )
{
}
//////////////////////////////////////////////////////////////////////////////
TQStringList pkgInterface::depends(const TQString &, int ) {return 0;}
TQString pkgInterface::doUninstall(int, const TQString &, bool &) {return 0;}
TQString pkgInterface::doInstall(int, const TQString &, bool &) {return 0;}
////////////////////////////////////////////////////////////////////////////
bool pkgInterface::ifExe(TQString exe) {
if (!TDEGlobal::dirs()->findExe( exe ).isNull()) {
return TRUE;
} else {
kdDebug() << "Program not found: " << exe << "\n";
errExe = exe;
return FALSE;
}
}
void pkgInterface::listPackages(TQPtrList<packageInfo> *pki)
{
listInstalledPackages(pki);
if (packageLoc) {
for (cacheObj *cp = packageLoc->first(); cp != 0; cp = packageLoc->next()) {
TQString s = getDir(cp);
if (!s.isEmpty())
listDir(pki, s, cp->location, cp->subdirs);
}
}
}
void pkgInterface::smerge(packageInfo *)
{ }
void pkgInterface::listDir(TQPtrList<packageInfo> *pki, const TQString &fname, const TQString &dir, bool subdirs)
{
// fname - path to directory or cached remote infromation file
// dir - url of directory
TQString name, size, rfile;
packageInfo *p;
TQString sline( queryMsg + fname );
kpackage->setStatus(sline);
kdDebug() << "listDir fn=" << fname << " dir=" << dir << endl;
TQDir d(fname,packagePattern);
if (subdirs)
d.setMatchAllDirs( TRUE ); // list contains subdirs
else
d.setMatchAllDirs( FALSE ); // list contains no subdirs
if (d.exists()) {
if ( d.isReadable() ) {
TQString pn;
const TQFileInfoList *list = d.entryInfoList();
TQFileInfoListIterator it( *list ); // create list iterator
TQFileInfo *fi; // pointer for traversing
while ( (fi=it.current()) ) { // for each entry...
if ( fi->isDir() ) {
// entry is a subdir
if ( fi->fileName() != TQString::fromLatin1(".") &&
fi->fileName() != TQString::fromLatin1("..") )
{
// not current dir and not parent dir
// -> recursive call:
listDir( pki, dir + "/" + fi->fileName(), dir + "/" + fi->fileName(), subdirs );
} else {
// current dir or parent dir
// -> notihng to do
;
}
} else {
// entry is a file
if (opts->PkgRead) {
rfile = fname + "/";
rfile += fi->fileName();
p = getPackageInfo('u',rfile, 0);
if (p) {
p->info.insert("filename", fi->fileName());
p->info.insert("base", dir);
}
} else {
p = collectDir(fi->fileName(),pn.setNum(fi->size()),dir);
}
if (p) {
smerge(p);
if (!p->pkgInsert(pki, typeID, FALSE))
delete p;
}
}
++it; // goto next list element
}
} else {
// directory is not readable
kdDebug() << TQString("WARNING: directory '%1' not readable (will be ignored) !\n").arg(d.absPath() ) << endl;
}
} else {
TQFile f(fname);
if ( f.open(IO_ReadOnly) ) {
TQTextStream t( &f );
TQString name;
while ( !t.eof() ) {
name = t.readLine();
if (!t.eof() ) {
size = t.readLine();
} else
size = "";
packageInfo *p = collectDir(name,size,dir);
if (p) {
smerge(p);
if (!p->pkgInsert(pki, typeID, FALSE))
delete p;
}
}
f.close();
}
}
}
packageInfo *pkgInterface::collectDir(const TQString &name, const TQString &size, const TQString &dir)
{
kdDebug() << "collectDir " << name << " " << size << " " << dir << endl;
TQString n,v;
if (parseName(name, &n, &v)) {
TQMap<TQString, TQString> a;
a.insert("group", "NEW");
a.insert("name", n);
a.insert("version", v);
a.insert("file-size", size);
a.insert("filename", name);
a.insert("base", dir);
packageInfo *i = new packageInfo(a,this);
i->packageState = packageInfo::AVAILABLE;
// i->packageState = packageInfo::NEW;
return i;
}
return 0;
}
TQString pkgInterface::getPackList(cacheObj *cp)
{
TQString tmpf;
int res;
TQString url = cp->location;
kdDebug() << "pkgInterface::getPackList " << url << " " << cp->cacheFile << "\n";
if ((res = cacheObj::newDCache(url, cp->cacheFile, tmpf))) {
if (res < 0)
return 0;
unlink(TQFile::encodeName(tmpf));
if (kpkg)
kpackage->setStatus(i18n("Starting Kio"));
Kio tdeio;
if (tdeio.download(url, tmpf)) {
if (kpkg)
kpackage->setStatus(i18n("Kio finished"));
TQFileInfo f(tmpf);
if (!(f.exists() && f.size() > 0)) {
unlink(TQFile::encodeName(tmpf));
return "";
} else {
return tmpf;
}
} else {
if (kpkg)
kpackage->setStatus(i18n("Kio failed"));
return "";
}
} else {
return tmpf;
}
}
TQString pkgInterface::getDir(cacheObj *cp) {
int res;
TQString tmpDir;
TQString url = cp->location;
if ((res = cacheObj::newDCache(url, cp->cacheFile, tmpDir))) {
if (res < 0)
return TQString();
Kiod kiod;
if (kiod.listDir(url,tmpDir, cp->subdirs)) {
TQFileInfo fi (tmpDir);
CacheList cl (fi.dirPath());
cl.append (fi.fileName());
cl.write();
return tmpDir;
} else {
KpMsgE(i18n("Cannot read folder %1").arg(url),FALSE);
unlink(tmpDir.ascii());
return TQString();
}
} else {
return tmpDir;
}
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::provMap(const TQString &p)
{
// kdDebug() << "provMap=>" << p << endl;
return p;
}
//////////////////////////////////////////////////////////////////////////////
TQStringList pkgInterface::verify(packageInfo *, const TQStringList &files)
{
int p = 0;
uint c = 0;
TQStringList errorlist;
TQDir d;
if (hostName.isEmpty()) {
uint step = (files.count() / 100) + 1;
kpackage->setStatus(i18n("Verifying"));
kpackage->setPercent(0);
for( TQStringList::ConstIterator it = files.begin();
it != files.end();
it++)
{
// Update the status progress
c++;
if(c > step) {
c=0; p++;
kpackage->setPercent(p);
}
if (!d.exists(*it)) {
errorlist.append(*it);
}
}
kpackage->setPercent(100);
}
return errorlist;
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::uninstall(int uninstallFlags, packageInfo *p, bool &test)
{
TQString packs( p->getProperty("name"));
return doUninstall(uninstallFlags, packs, test);
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::uninstall(int uninstallFlags, TQPtrList<packageInfo> *p, bool &test)
{
TQString packs;
packageInfo *i;
for (i = p->first(); i!= 0; i = p->next()) {
packs += i->getProperty("name");
packs += " ";
}
return doUninstall( uninstallFlags, packs, test);
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::install(int installFlags, packageInfo *p, bool &test)
{
TQString fname = p->fetchFilename();
return doInstall(installFlags, fname, test);
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::install(int installFlags, TQPtrList<packageInfo> *p, bool &test)
{
TQString packs = "";
packageInfo *i;
for (i = p->first(); i!= 0; i = p->next()) {
TQString fname = i->fetchFilename();
if (!fname.isEmpty()) {
packs += fname;
packs += " ";
}
}
return doInstall(installFlags, packs, test);
}
//////////////////////////////////////////////////////////////////////////////
TQStringList pkgInterface::listInstalls(const TQStringList &packs, bool , bool &cancel)
{
cancel = FALSE;
return packs;
}
//////////////////////////////////////////////////////////////////////////////
TQString pkgInterface::setOptions(int flags, TQPtrList<param> ¶ms)
{
int i;
TQString s;
param *p;
i = 0;
for ( p=params.first(); p != 0; p=params.next(), i++ ) {
if ((flags>>i & 1) ^ p->invert) {
s += p->flag + " ";
} else {
if (!p->flagA.isEmpty())
s += p->flagA + " ";
}
}
return s;
}
TQStringList pkgInterface::readApt()
{
return 0;
}
void pkgInterface::writeApt(const TQStringList &)
{
}
#include "pkgInterface.moc"