/* This file is part of the KDE project Copyright (C) 2003 Julian Rockey <linux@jrockey.com> Copyright (C) 2003 Alexander Dymo <cloudtemple@mksat.net> Copyright (C) 2003 Mario Scalas <mario.scalas@libero.it> This library is free software; you can redistribute it and/or modify it under the terms of the GNU Library General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Library General Public License for more details. You should have received a copy of the GNU Library General Public License along with this library; see the file COPYING.LIB. If not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include <tqstringlist.h> #include <tqdir.h> #include <tqfileinfo.h> #include <kdebug.h> #include <unistd.h> #include <limits.h> #include <stdlib.h> #include "urlutil.h" #include <tdeversion.h> /////////////////////////////////////////////////////////////////////////////// // Namespace URLUtil /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::filename(const TQString & name) { int slashPos = name.findRev("/"); return slashPos<0 ? name : name.mid(slashPos+1); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::directory(const TQString & name) { int slashPos = name.findRev("/"); return slashPos<0 ? TQString("") : name.left(slashPos); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::getRelativePath(const TQString& basepath, const TQString& destpath) { TQString relpath = "."; if (!TQFile::exists(basepath) || !TQFile::exists(destpath)) return ""; TQStringList basedirs = TQStringList::split(TQString( TQChar( TQDir::separator() ) ),basepath); TQStringList destdirs = TQStringList::split(TQString( TQChar( TQDir::separator() ) ),destpath); int maxCompare=0; if (basedirs.count()>=destdirs.count()) maxCompare=destdirs.count(); else maxCompare=basedirs.count(); int lastCommonDir=-1; for (int i=0; i<maxCompare; i++) { if (basedirs[i] != destdirs[i]) break; lastCommonDir=i; } for (uint i=0;i<basedirs.count()-(lastCommonDir+1); i++) relpath += TQString( TQChar( TQDir::separator() ) )+TQString(".."); for (int i=0; i<lastCommonDir+1; i++) destdirs.pop_front(); if (destdirs.count()) relpath += TQString( TQChar( TQDir::separator() ) )+destdirs.join( TQChar( TQDir::separator() ) ); return TQDir::cleanDirPath(relpath); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::relativePath(const KURL & parent, const KURL & child, uint slashPolicy) { bool slashPrefix = slashPolicy & SLASH_PREFIX; bool slashSuffix = slashPolicy & SLASH_SUFFIX; if (parent.equals(child,true)) return slashPrefix ? TQString("/") : TQString(""); if (!parent.isParentOf(child)) return TQString(); int a=slashPrefix ? -1 : 1; int b=slashSuffix ? 1 : -1; return child.path(b).mid(parent.path(a).length()); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::relativePath(const TQString & parent, const TQString & child, uint slashPolicy) { return relativePath(KURL(parent), KURL(child), slashPolicy); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::upDir(const TQString & path, bool slashSuffix) { int slashPos = path.findRev("/"); if (slashPos<1) return TQString(); return path.mid(0,slashPos+ (slashSuffix ? 1 : 0) ); } /////////////////////////////////////////////////////////////////////////////// KURL URLUtil::mergeURL(const KURL & source, const KURL & dest, const KURL & child) { // if already a child of source, then fine if (source.isParentOf(child) || source.equals(child,true)) return child; // if not a child of dest, return blank URL (error) if (!dest.isParentOf(child) && !dest.equals(child,true)) return KURL(); // if child is same as dest, return source if (dest.equals(child,true)) return source; // calculate TQString childUrlStr = child.url(-1); TQString destStemStr = dest.url(1); TQString sourceStemStr = source.url(1); return KURL(sourceStemStr.append( childUrlStr.mid( destStemStr.length() ) ) ); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::getExtension(const TQString & path) { int dotPos = path.findRev('.'); if (dotPos<0) return TQString(""); return path.mid(dotPos+1); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::extractPathNameRelative(const KURL &baseDirUrl, const KURL &url ) { TQString absBase = extractPathNameAbsolute( baseDirUrl ), absRef = extractPathNameAbsolute( url ); int i = absRef.find( absBase, 0, true ); if (i == -1) return TQString(); if (absRef == absBase) return TQString( "." ); else return absRef.replace( 0, absBase.length(), TQString() ); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::extractPathNameRelative(const TQString &basePath, const KURL &url ) { KURL baseDirUrl = KURL::fromPathOrURL( basePath ); return extractPathNameRelative( baseDirUrl, url ); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::extractPathNameRelative(const TQString &basePath, const TQString &absFilePath ) { KURL baseDirUrl = KURL::fromPathOrURL( basePath ), fileUrl = KURL::fromPathOrURL( absFilePath ); return extractPathNameRelative( baseDirUrl, fileUrl ); } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::extractPathNameAbsolute( const KURL &url ) { if (isDirectory( url )) return url.path( +1 ); // with trailing "/" if none is present else { // Ok, this is an over-tight pre-condition on "url" since I hope nobody will never // stress this function with absurd cases ... but who knows? /* TQString path = url.path(); TQFileInfo fi( path ); // Argh: TQFileInfo is back ;)) return ( fi.exists()? path : TQString() ); */ return url.path(); } } /////////////////////////////////////////////////////////////////////////////// bool URLUtil::isDirectory( const KURL &url ) { return isDirectory( url.path() ); } /////////////////////////////////////////////////////////////////////////////// bool URLUtil::isDirectory( const TQString &absFilePath ) { return TQDir( absFilePath ).exists(); } /////////////////////////////////////////////////////////////////////////////// void URLUtil::dump( const KURL::List &urls, const TQString &aMessage ) { if (!aMessage.isNull()) { kdDebug(9000) << aMessage << endl; } kdDebug(9000) << " List has " << urls.count() << " elements." << endl; for (size_t i = 0; i<urls.count(); ++i) { KURL url = urls[ i ]; // kdDebug(9000) << " * Element = " << url.path() << endl; } } /////////////////////////////////////////////////////////////////////////////// TQStringList URLUtil::toRelativePaths( const TQString &baseDir, const KURL::List &urls) { TQStringList paths; for (size_t i=0; i<urls.count(); ++i) { paths << extractPathNameRelative( baseDir, urls[i] ); } return paths; } /////////////////////////////////////////////////////////////////////////////// TQString URLUtil::relativePathToFile( const TQString & dirUrl, const TQString & fileUrl ) { if (dirUrl.isEmpty() || (dirUrl == "/")) return fileUrl; TQStringList dir = TQStringList::split("/", dirUrl, false); TQStringList file = TQStringList::split("/", fileUrl, false); TQString resFileName = file.last(); file.remove(file.last()); uint i = 0; while ( (i < dir.count()) && (i < (file.count())) && (dir[i] == file[i]) ) i++; TQString result_up; TQString result_down; TQString currDir; TQString currFile; do { i >= dir.count() ? currDir = "" : currDir = dir[i]; i >= file.count() ? currFile = "" : currFile = file[i]; //tqWarning("i = %d, currDir = %s, currFile = %s", i, currDir.latin1(), currFile.latin1()); if (currDir.isEmpty() && currFile.isEmpty()) break; else if (currDir.isEmpty()) result_down += file[i] + "/"; else if (currFile.isEmpty()) result_up += "../"; else { result_down += file[i] + "/"; result_up += "../"; } i++; } while ( (!currDir.isEmpty()) || (!currFile.isEmpty()) ); return result_up + result_down + resFileName; } /////////////////////////////////////////////////////////////////////////////// //TODO: remove for KDE4 TQString URLUtil::canonicalPath( const TQString & path ) { TQDir dir(path); return dir.canonicalPath(); } /////////////////////////////////////////////////////////////////////////////// //written by "Dawit A." <adawit@kde.org> //borrowed from his patch to KShell TQString URLUtil::envExpand ( const TQString& str ) { uint len = str.length(); if (len > 1 && str[0] == '$') { int pos = str.find ('/'); if (pos < 0) pos = len; char* ret = getenv( TQConstString(str.unicode()+1, pos-1).string().local8Bit().data() ); if (ret) { TQString expandedStr ( TQFile::decodeName( ret ) ); if (pos < (int)len) expandedStr += str.mid(pos); return expandedStr; } } return str; }