summaryrefslogtreecommitdiffabout
authorulf69 <ulf69>2004-08-05 21:42:29 (UTC)
committer ulf69 <ulf69>2004-08-05 21:42:29 (UTC)
commit6ee7d4f5119837f89ec534c8c5c73845d521e135 (patch) (side-by-side diff)
tree265d25e37da63a00ae3302059c2c628efb57b570
parentc3a704f5acda9cf9fee66e5c0b1b864f3b7dd852 (diff)
downloadkdepimpi-6ee7d4f5119837f89ec534c8c5c73845d521e135.zip
kdepimpi-6ee7d4f5119837f89ec534c8c5c73845d521e135.tar.gz
kdepimpi-6ee7d4f5119837f89ec534c8c5c73845d521e135.tar.bz2
added tmp as a resourcetype. KDE handled tmp differently, but we do not need
the special handling. So i simply added it as standard resource type
Diffstat (more/less context) (ignore whitespace changes)
-rw-r--r--microkde/kdecore/kstandarddirs.cpp146
1 files changed, 73 insertions, 73 deletions
diff --git a/microkde/kdecore/kstandarddirs.cpp b/microkde/kdecore/kstandarddirs.cpp
index e1c78f6..75205d6 100644
--- a/microkde/kdecore/kstandarddirs.cpp
+++ b/microkde/kdecore/kstandarddirs.cpp
@@ -17,128 +17,128 @@
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
/*
* Author: Stephan Kulow <coolo@kde.org> and Sirtaj Singh Kang <taj@kde.org>
* Version: $Id$
* Generated: Thu Mar 5 16:05:28 EST 1998
*/
//US #include "config.h"
#include <stdlib.h>
#include <assert.h>
//US#include <errno.h>
//US #ifdef HAVE_SYS_STAT_H
//US #include <sys/stat.h>
//US #endif
//US#include <sys/types.h>
//US#include <dirent.h>
//US#include <pwd.h>
#include <qregexp.h>
#include <qasciidict.h>
#include <qdict.h>
#include <qdir.h>
#include <qfileinfo.h>
#include <qstring.h>
#include <qapplication.h>
#include <qstringlist.h>
#include "kstandarddirs.h"
#include "kconfig.h"
#include "kdebug.h"
//US #include "kinstance.h"
#include "kshell.h"
//US#include <sys/param.h>
//US#include <unistd.h>
//US
QString KStandardDirs::mAppDir = QString::null;
template class QDict<QStringList>;
#if 0
#include <qtextedit.h>
-void ddd( QString op )
+void ddd( QString op )
{
static QTextEdit * dot = 0;
- if ( ! dot )
+ if ( ! dot )
dot = new QTextEdit();
dot->show();
dot->append( op );
}
#endif
class KStandardDirs::KStandardDirsPrivate
{
public:
KStandardDirsPrivate()
: restrictionsActive(false),
dataRestrictionActive(false)
{ }
bool restrictionsActive;
bool dataRestrictionActive;
QAsciiDict<bool> restrictions;
QStringList xdgdata_prefixes;
QStringList xdgconf_prefixes;
};
static const char* const types[] = {"html", "icon", "apps", "sound",
"data", "locale", "services", "mime",
- "servicetypes", "config", "exe",
- "wallpaper", "lib", "pixmap", "templates",
- "module", "qtplugins",
+ "servicetypes", "config", "exe", "tmp",
+ "wallpaper", "lib", "pixmap", "templates",
+ "module", "qtplugins",
"xdgdata-apps", "xdgdata-dirs", "xdgconf-menu", 0 };
static int tokenize( QStringList& token, const QString& str,
const QString& delim );
KStandardDirs::KStandardDirs( ) : addedCustoms(false)
{
d = new KStandardDirsPrivate;
dircache.setAutoDelete(true);
relatives.setAutoDelete(true);
absolutes.setAutoDelete(true);
savelocations.setAutoDelete(true);
addKDEDefaults();
}
KStandardDirs::~KStandardDirs()
{
delete d;
}
bool KStandardDirs::isRestrictedResource(const char *type, const QString& relPath) const
{
if (!d || !d->restrictionsActive)
return false;
if (d->restrictions[type])
return true;
if (strcmp(type, "data")==0)
{
applyDataRestrictions(relPath);
if (d->dataRestrictionActive)
{
d->dataRestrictionActive = false;
return true;
}
}
return false;
}
void KStandardDirs::applyDataRestrictions(const QString &relPath) const
{
QString key;
int i = relPath.find('/');
if (i != -1)
key = "data_"+relPath.left(i);
else
key = "data_"+relPath;
@@ -313,574 +313,574 @@ Q_UINT32 KStandardDirs::calcResourceHash( const char *type,
}
return hash;
}
*/
QStringList KStandardDirs::findDirs( const char *type,
const QString& reldir ) const
{
QStringList list;
checkConfig();
if (d && d->restrictionsActive && (strcmp(type, "data")==0))
applyDataRestrictions(reldir);
QStringList candidates = resourceDirs(type);
QDir testdir;
for (QStringList::ConstIterator it = candidates.begin();
it != candidates.end(); it++) {
testdir.setPath(*it + reldir);
if (testdir.exists())
list.append(testdir.absPath() + '/');
}
return list;
}
QString KStandardDirs::findResourceDir( const char *type,
const QString& filename) const
{
#ifndef NDEBUG
if (filename.isEmpty()) {
kdWarning() << "filename for type " << type << " in KStandardDirs::findResourceDir is not supposed to be empty!!" << endl;
return QString::null;
}
#endif
if (d && d->restrictionsActive && (strcmp(type, "data")==0))
applyDataRestrictions(filename);
QStringList candidates = resourceDirs(type);
QString fullPath;
#ifdef DESKTOP_VERSION
#ifdef _WIN32_
candidates.prepend( qApp->applicationDirPath () +"\\");
#else
candidates.prepend( qApp->applicationDirPath () +"/");
#endif
#endif
- for (QStringList::ConstIterator it = candidates.begin(); it != candidates.end(); it++)
+ for (QStringList::ConstIterator it = candidates.begin(); it != candidates.end(); it++)
{
//qDebug("looking for dir %s - file %s", (*it).latin1(), filename.latin1());
if (exists(*it + filename))
return *it;
}
#ifndef NDEBUG
if(false && type != "locale")
qDebug("KStdDirs::findResDir(): can't find %s ", filename.latin1());
-
+
#endif
return QString::null;
}
bool KStandardDirs::exists(const QString &fullPath)
{
//US struct stat buff;
QFileInfo fullPathInfo(QFile::encodeName(fullPath));
//US if (access(QFile::encodeName(fullPath), R_OK) == 0 && fullPathInfo.isReadable())
if (fullPathInfo.isReadable())
- {
+ {
if (fullPath.at(fullPath.length() - 1) != '/') {
//US if (S_ISREG( buff.st_mode ))
if (fullPathInfo.isFile())
return true;
- }
+ }
else {
-//US if (S_ISDIR( buff.st_mode ))
- if (fullPathInfo.isDir())
+//US if (S_ISDIR( buff.st_mode ))
+ if (fullPathInfo.isDir())
return true;
}
}
return false;
}
static void lookupDirectory(const QString& path, const QString &relPart,
const QRegExp &regexp,
QStringList& list,
QStringList& relList,
bool recursive, bool uniq)
{
QString pattern = regexp.pattern();
if (recursive || pattern.contains('?') || pattern.contains('*'))
{
// We look for a set of files.
//US DIR *dp = opendir( QFile::encodeName(path));
QDir dp(QFile::encodeName(path));
-
+
if (!dp.exists())
return;
static int iii = 0;
++iii;
if ( iii == 5 )
abort();
assert(path.at(path.length() - 1) == '/');
//US struct dirent *ep;
//US struct stat buff;
QString _dot(".");
QString _dotdot("..");
//US while( ( ep = readdir( dp ) ) != 0L )
QStringList direntries = dp.entryList();
QStringList::Iterator it = direntries.begin();
-
+
while ( it != list.end() ) // for each file...
{
-
+
//US QString fn( QFile::decodeName(ep->d_name));
QString fn = (*it); // dp.entryList already decodes
it++;
if ( fn.isNull() )
break;
-
+
if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1).latin1() == '~' )
continue;
/*US
if (!recursive && !regexp.exactMatch(fn))
continue; // No match
*/
//US this should do the same:
int pos = regexp.match(fn);
if (!recursive && !pos == 0)
continue; // No match
QString pathfn = path + fn;
-/*US
+/*US
if ( stat( QFile::encodeName(pathfn), &buff ) != 0 ) {
kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
continue; // Couldn't stat (e.g. no read permissions)
}
-
- if ( recursive )
+
+ if ( recursive )
{
if ( S_ISDIR( buff.st_mode )) {
lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, uniq);
}
*/
//US replacement:
QFileInfo pathfnInfo(QFile::encodeName(pathfn));
if ( pathfnInfo.isReadable() == false )
{
//US kdDebug() << "Error stat'ing " << pathfn << " : " << perror << endl;
continue; // Couldn't stat (e.g. no read permissions)
}
-
- if ( recursive )
+
+ if ( recursive )
{
if ( pathfnInfo.isDir()) {
lookupDirectory(pathfn + '/', relPart + fn + '/', regexp, list, relList, recursive, uniq);
}
-
-
-/*US
+
+
+/*US
if (!regexp.exactMatch(fn))
continue; // No match
*/
//US this should do the same:
pos = regexp.match(fn);
if (!pos == 0)
continue; // No match
}
//US if ( S_ISREG( buff.st_mode))
if ( pathfnInfo.isFile())
{
if (!uniq || !relList.contains(relPart + fn))
{
list.append( pathfn );
relList.append( relPart + fn );
}
}
}
//US closedir( dp );
}
else
{
// We look for a single file.
QString fn = pattern;
QString pathfn = path + fn;
//US struct stat buff;
QFileInfo pathfnInfo(QFile::encodeName(pathfn));
//US if ( stat( QFile::encodeName(pathfn), &buff ) != 0 )
if ( pathfnInfo.isReadable() == false )
return; // File not found
-
+
//US if ( S_ISREG( buff.st_mode))
if ( pathfnInfo.isFile())
{
if (!uniq || !relList.contains(relPart + fn))
{
list.append( pathfn );
relList.append( relPart + fn );
}
}
}
}
static void lookupPrefix(const QString& prefix, const QString& relpath,
const QString& relPart,
const QRegExp &regexp,
QStringList& list,
QStringList& relList,
bool recursive, bool uniq)
{
if (relpath.isNull()) {
lookupDirectory(prefix, relPart, regexp, list,
relList, recursive, uniq);
return;
}
QString path;
QString rest;
if (relpath.length())
{
int slash = relpath.find('/');
if (slash < 0)
rest = relpath.left(relpath.length() - 1);
else {
path = relpath.left(slash);
rest = relpath.mid(slash + 1);
}
}
assert(prefix.at(prefix.length() - 1) == '/');
//US struct stat buff;
if (path.contains('*') || path.contains('?')) {
QRegExp pathExp(path, true, true);
//US DIR *dp = opendir( QFile::encodeName(prefix) );
QDir dp(QFile::encodeName(prefix));
-
-//US if (!dp)
+
+//US if (!dp)
if (!dp.exists())
{
return;
}
//US struct dirent *ep;
QString _dot(".");
QString _dotdot("..");
//US while( ( ep = readdir( dp ) ) != 0L )
QStringList direntries = dp.entryList();
QStringList::Iterator it = direntries.begin();
-
+
while ( it != list.end() ) // for each file...
{
//US QString fn( QFile::decodeName(ep->d_name));
QString fn = (*it); // dp.entryList() already encodes the strings
it++;
-
+
if (fn == _dot || fn == _dotdot || fn.at(fn.length() - 1) == '~')
continue;
#ifdef DESKTOP_VERSION
if (pathExp.search(fn) == -1)
continue; // No match
#else
//US this should do the same:
if (pathExp.find(fn, 0) == -1)
continue; // No match
#endif
QString rfn = relPart+fn;
fn = prefix + fn;
//US if ( stat( QFile::encodeName(fn), &buff ) != 0 )
QFileInfo fnInfo(QFile::encodeName(fn));
if ( fnInfo.isReadable() == false )
{
//US kdDebug() << "Error statting " << fn << " : " << perror << endl;
continue; // Couldn't stat (e.g. no permissions)
}
//US if ( S_ISDIR( buff.st_mode ))
if ( fnInfo.isDir() )
-
+
lookupPrefix(fn + '/', rest, rfn + '/', regexp, list, relList, recursive, uniq);
}
//US closedir( dp );
} else {
// Don't stat, if the dir doesn't exist we will find out
// when we try to open it.
lookupPrefix(prefix + path + '/', rest,
relPart + path + '/', regexp, list,
relList, recursive, uniq);
}
}
QStringList
KStandardDirs::findAllResources( const char *type,
const QString& filter,
bool recursive,
bool uniq,
QStringList &relList) const
{
QStringList list;
if (filter.at(0) == '/') // absolute paths we return
{
list.append( filter);
return list;
}
QString filterPath;
QString filterFile;
if (filter.length())
{
int slash = filter.findRev('/');
if (slash < 0)
filterFile = filter;
else {
filterPath = filter.left(slash + 1);
filterFile = filter.mid(slash + 1);
}
}
checkConfig();
if (d && d->restrictionsActive && (strcmp(type, "data")==0))
applyDataRestrictions(filter);
QStringList candidates = resourceDirs(type);
if (filterFile.isEmpty())
filterFile = "*";
QRegExp regExp(filterFile, true, true);
for (QStringList::ConstIterator it = candidates.begin();
it != candidates.end(); it++)
{
lookupPrefix(*it, filterPath, "", regExp, list,
relList, recursive, uniq);
}
return list;
}
QStringList
KStandardDirs::findAllResources( const char *type,
const QString& filter,
bool recursive,
bool uniq) const
{
QStringList relList;
return findAllResources(type, filter, recursive, uniq, relList);
}
-QString
+QString
KStandardDirs::realPath(const QString &dirname)
{
#ifdef _WIN32_
return dirname;
#else
//US char realpath_buffer[MAXPATHLEN + 1];
//US memset(realpath_buffer, 0, MAXPATHLEN + 1);
char realpath_buffer[250 + 1];
memset(realpath_buffer, 0, 250 + 1);
/* If the path contains symlinks, get the real name */
if (realpath( QFile::encodeName(dirname).data(), realpath_buffer) != 0) {
// succes, use result from realpath
int len = strlen(realpath_buffer);
realpath_buffer[len] = '/';
realpath_buffer[len+1] = 0;
return QFile::decodeName(realpath_buffer);
}
return dirname;
#endif
}
/*US
void KStandardDirs::createSpecialResource(const char *type)
{
char hostname[256];
hostname[0] = 0;
gethostname(hostname, 255);
QString dir = QString("%1%2-%3").arg(localkdedir()).arg(type).arg(hostname);
char link[1024];
link[1023] = 0;
int result = readlink(QFile::encodeName(dir).data(), link, 1023);
if ((result == -1) && (errno == ENOENT))
{
QString srv = findExe(QString::fromLatin1("lnusertemp"), KDEDIR+QString::fromLatin1("/bin"));
if (srv.isEmpty())
srv = findExe(QString::fromLatin1("lnusertemp"));
if (!srv.isEmpty())
{
system(QFile::encodeName(srv)+" "+type);
result = readlink(QFile::encodeName(dir).data(), link, 1023);
}
}
if (result > 0)
{
link[result] = 0;
if (link[0] == '/')
dir = QFile::decodeName(link);
else
dir = QDir::cleanDirPath(dir+QFile::decodeName(link));
}
addResourceDir(type, dir+'/');
}
*/
QStringList KStandardDirs::resourceDirs(const char *type) const
{
QStringList *candidates = dircache.find(type);
if (!candidates) { // filling cache
-/*US
+/*US
if (strcmp(type, "socket") == 0)
const_cast<KStandardDirs *>(this)->createSpecialResource(type);
else if (strcmp(type, "tmp") == 0)
const_cast<KStandardDirs *>(this)->createSpecialResource(type);
else if (strcmp(type, "cache") == 0)
const_cast<KStandardDirs *>(this)->createSpecialResource(type);
*/
QDir testdir;
candidates = new QStringList();
QStringList *dirs;
bool restrictionActive = false;
if (d && d->restrictionsActive)
{
if (d->dataRestrictionActive)
restrictionActive = true;
else if (d->restrictions["all"])
restrictionActive = true;
else if (d->restrictions[type])
restrictionActive = true;
d->dataRestrictionActive = false; // Reset
}
dirs = relatives.find(type);
if (dirs)
{
bool local = true;
const QStringList *prefixList = 0;
if (strncmp(type, "xdgdata-", 8) == 0)
prefixList = &(d->xdgdata_prefixes);
else if (strncmp(type, "xdgconf-", 8) == 0)
prefixList = &(d->xdgconf_prefixes);
else
prefixList = &prefixes;
-
+
for (QStringList::ConstIterator pit = prefixList->begin();
pit != prefixList->end();
pit++)
{
for (QStringList::ConstIterator it = dirs->begin();
it != dirs->end(); ++it) {
QString path = realPath(*pit + *it);
testdir.setPath(path);
if (local && restrictionActive)
continue;
if ((local || testdir.exists()) && !candidates->contains(path))
candidates->append(path);
}
local = false;
}
}
dirs = absolutes.find(type);
if (dirs)
for (QStringList::ConstIterator it = dirs->begin();
it != dirs->end(); ++it)
{
testdir.setPath(*it);
if (testdir.exists())
{
QString filename = realPath(*it);
if (!candidates->contains(filename))
candidates->append(filename);
}
}
dircache.insert(type, candidates);
}
#if 0
kdDebug() << "found dirs for resource " << type << ":" << endl;
for (QStringList::ConstIterator pit = candidates->begin();
pit != candidates->end();
pit++)
{
fprintf(stderr, "%s\n", (*pit).latin1());
}
#endif
return *candidates;
}
/*US
QString KStandardDirs::findExe( const QString& appname,
const QString& pstr, bool ignore)
{
QFileInfo info;
// absolute path ?
if (appname.startsWith(QString::fromLatin1("/")))
{
info.setFile( appname );
if( info.exists() && ( ignore || info.isExecutable() )
&& info.isFile() ) {
return appname;
}
return QString::null;
}
//US QString p = QString("%1/%2").arg(__KDE_BINDIR).arg(appname);
QString p = QString("%1/%2").arg(appname).arg(appname);
qDebug("KStandardDirs::findExe this is probably wrong");
-
+
info.setFile( p );
if( info.exists() && ( ignore || info.isExecutable() )
&& ( info.isFile() || info.isSymLink() ) ) {
return p;
}
QStringList tokens;
p = pstr;
if( p.isNull() ) {
p = getenv( "PATH" );
}
tokenize( tokens, p, ":\b" );
// split path using : or \b as delimiters
for( unsigned i = 0; i < tokens.count(); i++ ) {
p = tokens[ i ];
if ( p[ 0 ] == '~' )
{
int len = p.find( '/' );
if ( len == -1 )
len = p.length();
if ( len == 1 )
p.replace( 0, 1, QDir::homeDirPath() );
else
{
QString user = p.mid( 1, len - 1 );
struct passwd *dir = getpwnam( user.local8Bit().data() );
if ( dir && strlen( dir->pw_dir ) )
p.replace( 0, len, QString::fromLocal8Bit( dir->pw_dir ) );
}
}
p += "/";
p += appname;
// Check for executable in this tokenized path
info.setFile( p );
if( info.exists() && ( ignore || info.isExecutable() )
&& ( info.isFile() || info.isSymLink() ) ) {
return p;
}
}
// If we reach here, the executable wasn't found.
@@ -962,676 +962,676 @@ QString KStandardDirs::kde_default(const char *type) {
return "share/applnk/";
if (!strcmp(type, "sound"))
return "share/sounds/";
if (!strcmp(type, "locale"))
return "share/locale/";
if (!strcmp(type, "services"))
return "share/services/";
if (!strcmp(type, "servicetypes"))
return "share/servicetypes/";
if (!strcmp(type, "mime"))
return "share/mimelnk/";
if (!strcmp(type, "cgi"))
return "cgi-bin/";
if (!strcmp(type, "wallpaper"))
return "share/wallpapers/";
if (!strcmp(type, "templates"))
return "share/templates/";
if (!strcmp(type, "exe"))
return "bin/";
if (!strcmp(type, "lib"))
return "lib/";
if (!strcmp(type, "module"))
return "lib/kde3/";
if (!strcmp(type, "qtplugins"))
return "lib/kde3/plugins";
if (!strcmp(type, "xdgdata-apps"))
return "applications/";
if (!strcmp(type, "xdgdata-dirs"))
return "desktop-directories/";
if (!strcmp(type, "xdgconf-menu"))
return "menus/";
qFatal("unknown resource type %s", type);
return QString::null;
}
QString KStandardDirs::saveLocation(const char *type,
const QString& suffix,
bool create) const
{
//qDebug("KStandardDirs::saveLocation called %s %s", type,suffix.latin1() );
//return "";
checkConfig();
QString *pPath = savelocations.find(type);
if (!pPath)
{
QStringList *dirs = relatives.find(type);
if (!dirs && (
- (strcmp(type, "socket") == 0) ||
+ (strcmp(type, "socket") == 0) ||
(strcmp(type, "tmp") == 0) ||
(strcmp(type, "cache") == 0) ))
{
(void) resourceDirs(type); // Generate socket|tmp|cache resource.
dirs = relatives.find(type); // Search again.
}
if (dirs)
{
// Check for existance of typed directory + suffix
if (strncmp(type, "xdgdata-", 8) == 0)
pPath = new QString(realPath(localxdgdatadir() + dirs->last()));
else if (strncmp(type, "xdgconf-", 8) == 0)
pPath = new QString(realPath(localxdgconfdir() + dirs->last()));
else
pPath = new QString(realPath(localkdedir() + dirs->last()));
}
else {
dirs = absolutes.find(type);
if (!dirs)
qFatal("KStandardDirs: The resource type %s is not registered", type);
pPath = new QString(realPath(dirs->last()));
}
-
+
savelocations.insert(type, pPath);
}
-
+
QString fullPath = *pPath + suffix;
//US struct stat st;
-//US if (stat(QFile::encodeName(fullPath), &st) != 0 || !(S_ISDIR(st.st_mode)))
+//US if (stat(QFile::encodeName(fullPath), &st) != 0 || !(S_ISDIR(st.st_mode)))
QFileInfo fullPathInfo(QFile::encodeName(fullPath));
- if (fullPathInfo.isReadable() || !fullPathInfo.isDir())
-
-
+ if (fullPathInfo.isReadable() || !fullPathInfo.isDir())
+
+
{
if(!create) {
#ifndef NDEBUG
qDebug("save location %s doesn't exist", fullPath.latin1());
#endif
return fullPath;
}
if(!makeDir(fullPath, 0700)) {
qWarning("failed to create %s", fullPath.latin1());
return fullPath;
}
dircache.remove(type);
}
return fullPath;
}
QString KStandardDirs::relativeLocation(const char *type, const QString &absPath)
{
QString fullPath = absPath;
int i = absPath.findRev('/');
if (i != -1)
{
fullPath = realPath(absPath.left(i+1))+absPath.mid(i+1); // Normalize
}
QStringList candidates = resourceDirs(type);
for (QStringList::ConstIterator it = candidates.begin();
it != candidates.end(); it++)
if (fullPath.startsWith(*it))
{
return fullPath.mid((*it).length());
}
return absPath;
}
bool KStandardDirs::makeDir(const QString& dir2, int mode)
{
QString dir = QDir::convertSeparators( dir2 );
#if 0
//LR
// we want an absolute path
if (dir.at(0) != '/')
return false;
QString target = dir;
uint len = target.length();
// append trailing slash if missing
if (dir.at(len - 1) != '/')
target += '/';
QString base("");
uint i = 1;
while( i < len )
{
//US struct stat st;
int pos = target.find('/', i);
base += target.mid(i - 1, pos - i + 1);
QCString baseEncoded = QFile::encodeName(base);
// bail out if we encountered a problem
//US if (stat(baseEncoded, &st) != 0)
QFileInfo baseEncodedInfo(baseEncoded);
if (!baseEncodedInfo.exists())
{
// Directory does not exist....
// Or maybe a dangling symlink ?
//US if (lstat(baseEncoded, &st) == 0)
if (baseEncodedInfo.isSymLink()) {
//US (void)unlink(baseEncoded); // try removing
QFile(baseEncoded).remove();
}
//US if ( mkdir(baseEncoded, (mode_t) mode) != 0)
QDir dirObj;
if ( dirObj.mkdir(baseEncoded) != true )
{
//US perror("trying to create local folder");
return false; // Couldn't create it :-(
}
}
i = pos + 1;
}
return true;
#endif
// ********************************************
// new code for WIN32
QDir dirObj;
-
+
// we want an absolute path
#ifndef _WIN32_
if (dir.at(0) != '/')
return false;
#endif
-
+
QString target = dir;
uint len = target.length();
#ifndef _WIN32_
// append trailing slash if missing
if (dir.at(len - 1) != '/')
target += '/';
#endif
QString base("");
uint i = 1;
while( i < len )
{
//US struct stat st;
#ifndef _WIN32_
int pos = target.find('/', i);
#else
int pos = target.find('\\', i);
#endif
if ( pos < 0 )
return true;
base += target.mid(i - 1, pos - i + 1);
//QMessageBox::information( 0,"cap111", base, 1 );
-/*US
+/*US
QCString baseEncoded = QFile::encodeName(base);
// bail out if we encountered a problem
if (stat(baseEncoded, &st) != 0)
{
// Directory does not exist....
// Or maybe a dangling symlink ?
if (lstat(baseEncoded, &st) == 0)
(void)unlink(baseEncoded); // try removing
-
+
if ( mkdir(baseEncoded, (mode_t) mode) != 0) {
perror("trying to create local folder");
return false; // Couldn't create it :-(
}
}
-*/
-
+*/
+
if (dirObj.exists(base) == false)
{
//qDebug("KStandardDirs::makeDir try to create : %s" , base.latin1());
if (dirObj.mkdir(base) != true)
{
qDebug("KStandardDirs::makeDir could not create: %s" , base.latin1());
return false;
}
}
i = pos + 1;
}
return true;
}
static QString readEnvPath(const char *env)
{
#ifdef _WIN32_
return "";
#else
QCString c_path = getenv(env);
if (c_path.isEmpty())
return QString::null;
return QFile::decodeName(c_path);
#endif
}
void KStandardDirs::addKDEDefaults()
{
//qDebug("ERROR: KStandardDirs::addKDEDefaults() called ");
//return;
QStringList kdedirList;
// begin KDEDIRS
QString kdedirs = readEnvPath("MICROKDEDIRS");
if (!kdedirs.isEmpty())
{
tokenize(kdedirList, kdedirs, ":");
}
else
{
QString kdedir = readEnvPath("MICROKDEDIR");
if (!kdedir.isEmpty())
{
kdedir = KShell::tildeExpand(kdedir);
kdedirList.append(kdedir);
}
}
//US kdedirList.append(KDEDIR);
-//US for embedded, add qtopia dir as kdedir
+//US for embedded, add qtopia dir as kdedir
#ifndef DESKTOP_VERSION
kdedirList.append(readEnvPath("QPEDIR" ));
#endif
#ifdef __KDE_EXECPREFIX
QString execPrefix(__KDE_EXECPREFIX);
if (execPrefix!="NONE")
kdedirList.append(execPrefix);
#endif
QString localKdeDir;
-
+
//US if (getuid())
if (true)
{
localKdeDir = readEnvPath("MICROKDEHOME");
if (!localKdeDir.isEmpty())
{
if (localKdeDir.at(localKdeDir.length()-1) != '/')
localKdeDir += '/';
}
else
{
localKdeDir = QDir::homeDirPath() + "/kdepim/";
}
}
else
{
// We treat root different to prevent root messing up the
// file permissions in the users home directory.
localKdeDir = readEnvPath("MICROKDEROOTHOME");
if (!localKdeDir.isEmpty())
{
if (localKdeDir.at(localKdeDir.length()-1) != '/')
localKdeDir += '/';
}
else
{
//US struct passwd *pw = getpwuid(0);
//US localKdeDir = QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root") + "/.microkde/";
- qDebug("KStandardDirs::addKDEDefaults: 1 has to be fixed");
+ qDebug("KStandardDirs::addKDEDefaults: 1 has to be fixed");
}
}
//US localKdeDir = appDir();
//US
-// qDebug("KStandardDirs::addKDEDefaults: localKdeDir=%s", localKdeDir.latin1());
+// qDebug("KStandardDirs::addKDEDefaults: localKdeDir=%s", localKdeDir.latin1());
if (localKdeDir != "-/")
{
localKdeDir = KShell::tildeExpand(localKdeDir);
addPrefix(localKdeDir);
}
for (QStringList::ConstIterator it = kdedirList.begin();
it != kdedirList.end(); it++)
{
QString dir = KShell::tildeExpand(*it);
addPrefix(dir);
}
// end KDEDIRS
// begin XDG_CONFIG_XXX
QStringList xdgdirList;
QString xdgdirs = readEnvPath("XDG_CONFIG_DIRS");
if (!xdgdirs.isEmpty())
{
tokenize(xdgdirList, xdgdirs, ":");
}
else
{
xdgdirList.clear();
xdgdirList.append("/etc/xdg");
}
QString localXdgDir = readEnvPath("XDG_CONFIG_HOME");
if (!localXdgDir.isEmpty())
{
if (localXdgDir.at(localXdgDir.length()-1) != '/')
localXdgDir += '/';
}
else
{
//US if (getuid())
if (true)
{
localXdgDir = QDir::homeDirPath() + "/.config/";
}
else
{
//US struct passwd *pw = getpwuid(0);
//US localXdgDir = QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root") + "/.config/";
- qDebug("KStandardDirs::addKDEDefaults: 2 has to be fixed");
+ qDebug("KStandardDirs::addKDEDefaults: 2 has to be fixed");
}
}
localXdgDir = KShell::tildeExpand(localXdgDir);
addXdgConfigPrefix(localXdgDir);
for (QStringList::ConstIterator it = xdgdirList.begin();
it != xdgdirList.end(); it++)
{
QString dir = KShell::tildeExpand(*it);
addXdgConfigPrefix(dir);
}
// end XDG_CONFIG_XXX
// begin XDG_DATA_XXX
xdgdirs = readEnvPath("XDG_DATA_DIRS");
if (!xdgdirs.isEmpty())
{
tokenize(xdgdirList, xdgdirs, ":");
}
else
{
xdgdirList.clear();
for (QStringList::ConstIterator it = kdedirList.begin();
it != kdedirList.end(); it++)
{
QString dir = *it;
if (dir.at(dir.length()-1) != '/')
dir += '/';
xdgdirList.append(dir+"share/");
}
-
+
xdgdirList.append("/usr/local/share/");
xdgdirList.append("/usr/share/");
}
localXdgDir = readEnvPath("XDG_DATA_HOME");
if (!localXdgDir.isEmpty())
{
if (localXdgDir.at(localXdgDir.length()-1) != '/')
localXdgDir += '/';
}
else
{
//US if (getuid())
if (true)
{
localXdgDir = QDir::homeDirPath() + "/.local/share/";
}
else
{
//US struct passwd *pw = getpwuid(0);
//US localXdgDir = QFile::decodeName((pw && pw->pw_dir) ? pw->pw_dir : "/root") + "/.local/share/";
- qDebug("KStandardDirs::addKDEDefaults: 3 has to be fixed");
+ qDebug("KStandardDirs::addKDEDefaults: 3 has to be fixed");
}
}
localXdgDir = KShell::tildeExpand(localXdgDir);
addXdgDataPrefix(localXdgDir);
for (QStringList::ConstIterator it = xdgdirList.begin();
it != xdgdirList.end(); it++)
{
QString dir = KShell::tildeExpand(*it);
-
+
addXdgDataPrefix(dir);
}
// end XDG_DATA_XXX
uint index = 0;
while (types[index] != 0) {
addResourceType(types[index], kde_default(types[index]));
index++;
}
addResourceDir("home", QDir::homeDirPath());
}
void KStandardDirs::checkConfig() const
{
-/*US
+/*US
if (!addedCustoms && KGlobal::_instance && KGlobal::_instance->_config)
const_cast<KStandardDirs*>(this)->addCustomized(KGlobal::_instance->_config);
*/
if (!addedCustoms && KGlobal::config())
const_cast<KStandardDirs*>(this)->addCustomized(KGlobal::config());
}
bool KStandardDirs::addCustomized(KConfig *config)
{
if (addedCustoms) // there are already customized entries
return false; // we just quite and hope they are the right ones
// save the numbers of config directories. If this changes,
// we will return true to give KConfig a chance to reparse
uint configdirs = resourceDirs("config").count();
// reading the prefixes in
QString oldGroup = config->group();
config->setGroup("Directories");
QStringList list;
QStringList::ConstIterator it;
list = config->readListEntry("prefixes");
for (it = list.begin(); it != list.end(); it++)
addPrefix(*it);
// iterating over all entries in the group Directories
// to find entries that start with dir_$type
-/*US
+/*US
QMap<QString, QString> entries = config->entryMap("Directories");
QMap<QString, QString>::ConstIterator it2;
for (it2 = entries.begin(); it2 != entries.end(); it2++)
{
QString key = it2.key();
if (key.left(4) == "dir_") {
// generate directory list, there may be more than 1.
QStringList dirs = QStringList::split(',', *it2);
QStringList::Iterator sIt(dirs.begin());
QString resType = key.mid(4, key.length());
for (; sIt != dirs.end(); ++sIt) {
addResourceDir(resType.latin1(), *sIt);
}
}
}
// Process KIOSK restrictions.
config->setGroup("KDE Resource Restrictions");
entries = config->entryMap("KDE Resource Restrictions");
for (it2 = entries.begin(); it2 != entries.end(); it2++)
{
QString key = it2.key();
if (!config->readBoolEntry(key, true))
{
d->restrictionsActive = true;
d->restrictions.insert(key.latin1(), &d->restrictionsActive); // Anything will do
dircache.remove(key.latin1());
}
}
*/
// save it for future calls - that will return
addedCustoms = true;
config->setGroup(oldGroup);
// return true if the number of config dirs changed
return (resourceDirs("config").count() != configdirs);
}
QString KStandardDirs::localkdedir() const
{
// Return the prefix to use for saving
return prefixes.first();
}
QString KStandardDirs::localxdgdatadir() const
{
// Return the prefix to use for saving
return d->xdgdata_prefixes.first();
}
QString KStandardDirs::localxdgconfdir() const
{
// Return the prefix to use for saving
return d->xdgconf_prefixes.first();
}
void KStandardDirs::setAppDir( const QString &appDir )
{
mAppDir = appDir;
- if ( mAppDir.right( 1 ) != "/" )
+ if ( mAppDir.right( 1 ) != "/" )
mAppDir += "/";
}
QString KStandardDirs::appDir()
-{
- return mAppDir;
+{
+ return mAppDir;
}
// just to make code more readable without macros
QString locate( const char *type,
const QString& filename/*US , const KInstance* inst*/ )
{
//US return inst->dirs()->findResource(type, filename);
return KGlobal::dirs()->findResource(type, filename);
}
QString locateLocal( const char *type,
const QString& filename/*US , const KInstance* inst*/ )
{
QString path = locateLocal(type, filename, true /*US, inst*/);
-
+
/*
static int ccc = 0;
++ccc;
if ( ccc > 13 )
abort();
*/
qDebug("locatelocal: %s" , path.latin1());
return path;
/*US why do we put all files into one directory. It is quit complicated.
why not staying with the original directorystructure ?
-
+
QString escapedFilename = filename;
escapedFilename.replace( QRegExp( "/" ), "_" );
QString path = KStandardDirs::appDir() + type + "_" + escapedFilename;
kdDebug() << "locate: '" << path << "'" << endl;
qDebug("locate: %s" , path.latin1());
return path;
*/
-//US so my proposal is this:
+//US so my proposal is this:
// QString escapedFilename = filename;
// escapedFilename.replace( QRegExp( "/" ), "_" );
#if 0
#ifdef _WIN32_
QString path = QDir::convertSeparators(KStandardDirs::appDir() + type + "/" + filename);
#else
QString path = KStandardDirs::appDir() + type + "/" + filename;
#endif
-
+
//US Create the containing dir if needed
QFileInfo fi ( path );
-
+
// QString dir=pathurl.directory();
// QMessageBox::information( 0,"path", path, 1 );
-
+
#ifdef _WIN32_
KStandardDirs::makeDir(path);
#else
KStandardDirs::makeDir(fi.dirPath( true ));
-#endif
-
+#endif
+
qDebug("locate22: %s" , path.latin1());
return path;
#endif
-
+
}
QString locateLocal( const char *type,
const QString& filename, bool createDir/*US , const KInstance* inst*/ )
{
// try to find slashes. If there are some, we have to
// create the subdir first
int slash = filename.findRev('/')+1;
if (!slash) // only one filename
//US return inst->dirs()->saveLocation(type, QString::null, createDir) + filename;
return KGlobal::dirs()->saveLocation(type, QString::null, createDir) + filename;
// split path from filename
QString dir = filename.left(slash);
QString file = filename.mid(slash);
//US return inst->dirs()->saveLocation(type, dir, createDir) + file;
return KGlobal::dirs()->saveLocation(type, dir, createDir) + file;
// ***************************************************************
#if 0
/*US why do we put all files into one directory. It is quit complicated.
why not staying with the original directorystructure ?
-
+
QString escapedFilename = filename;
escapedFilename.replace( QRegExp( "/" ), "_" );
QString path = KStandardDirs::appDir() + type + "_" + escapedFilename;
kdDebug() << "locate: '" << path << "'" << endl;
qDebug("locate: %s" , path.latin1());
return path;
*/
-//US so my proposal is this:
+//US so my proposal is this:
// QString escapedFilename = filename;
// escapedFilename.replace( QRegExp( "/" ), "_" );
#ifdef _WIN32_
QString path = QDir::convertSeparators(KStandardDirs::appDir() + type + "/" + filename);
#else
QString path = KStandardDirs::appDir() + type + "/" + filename;
#endif
-
+
//US Create the containing dir if needed
KURL pathurl;
pathurl.setPath(path);
QString dir=pathurl.directory();
// QMessageBox::information( 0,"path", path, 1 );
#ifdef _WIN32_
KStandardDirs::makeDir(path);
#else
KStandardDirs::makeDir(dir);
-#endif
-
+#endif
+
return path;
#endif
}