static KUrl findUrlForAccount( const KMail::ImapAccountBase * a ) {
assert( a );
const SieveConfig sieve = a->sieveConfig();
if ( !sieve.managesieveSupported() )
return KUrl();
if ( sieve.reuseConfig() ) {
// assemble Sieve url from the settings of the account:
KUrl u;
u.setProtocol( "sieve" );
u.setHost( a->host() );
u.setUser( a->login() );
u.setPass( a->passwd() );
u.setPort( sieve.port() );
u.addQueryItem( "x-mech", a->auth() == "*" ? "PLAIN" : a->auth() ); //translate IMAP LOGIN to PLAIN
if ( !a->useSSL() && !a->useTLS() )
u.addQueryItem( "x-allow-unencrypted", "true" );
u.setFileName( sieve.vacationFileName() );
return u;
} else {
KUrl u = sieve.alternateURL();
if ( u.protocol().toLower() == "sieve" && !a->useSSL() && !a->useTLS() && u.queryItem("x-allow-unencrypted").isEmpty() )
u.addQueryItem( "x-allow-unencrypted", "true" );
u.setFileName( sieve.vacationFileName() );
return u;
}
}
void ScanGallery::slotUrlsDropped(QDropEvent *ev, FileTreeViewItem *item)
{
KUrl::List urls = ev->mimeData()->urls();
if (urls.isEmpty()) return;
kDebug() << "onto" << (item==NULL ? "NULL" : item->url().prettyUrl())
<< "srcs" << urls.count() << "first" << urls.first();
if (item==NULL) return;
KUrl dest = item->url();
// Check whether the drop is on top of a directory (in which case we
// want to move/copy into it) or a file (move/copy into its containing
// directory).
if (!item->isDir()) dest.setFileName(QString::null);
dest.adjustPath(KUrl::AddTrailingSlash);
kDebug() << "resolved destination" << dest;
// Make the last URL to copy the one to select next
KUrl nextSel = dest;
nextSel.addPath(urls.back().fileName(KUrl::ObeyTrailingSlash));
m_nextUrlToShow = nextSel;
KIO::Job *job;
// TODO: top level window as 3rd parameter?
if (ev->dropAction()==Qt::MoveAction) job = KIO::move(urls, dest);
else job = KIO::copy(urls, dest);
connect(job, SIGNAL(result(KJob *)), SLOT(slotJobResult(KJob *)));
}
bool
M3UPlaylist::save( const KUrl &location, bool relative )
{
KUrl savePath = location;
//if the location is a directory append the name of this playlist.
if( savePath.fileName().isNull() )
savePath.setFileName( name() );
QFile file( savePath.path() );
if( !file.open( QIODevice::WriteOnly ) )
{
error() << "Unable to write to playlist " << savePath.path();
return false;
}
QTextStream stream( &file );
stream << "#EXTM3U\n";
KUrl::List urls;
QStringList titles;
QList<int> lengths;
foreach( Meta::TrackPtr track, m_tracks )
{
Q_ASSERT(track);
const KUrl &url = track->playableUrl();
int length = track->length() / 1000;
const QString &title = track->name();
const QString &artist = track->artist()->name();
if( !title.isEmpty() && !artist.isEmpty() && length )
{
stream << "#EXTINF:";
stream << QString::number( length );
stream << ',';
stream << artist << " - " << title;
stream << '\n';
}
if( url.protocol() == "file" )
{
if( relative )
{
const QFileInfo fi( file );
QString relativePath = KUrl::relativePath( fi.path(), url.path() );
relativePath.remove( 0, 2 ); //remove "./"
stream << relativePath;
}
else
{
stream << url.path();
}
}
else
{
stream << url.url();
}
stream << "\n";
}
/**
* Exports the current model to XHTML in a directory named as the model
* with the .xmi suffix removed. The XHTML file will have the same name
* with the .html suffix. Figures will be named as the corresponding
* diagrams in the GUI
* @todo change file naming to avoid paths with spaces or non-ASCII chars
* @todo better handling of error conditions
* @return true if saving is successful and false otherwise.
*/
bool XhtmlGenerator::generateXhtmlForProject()
{
KUrl url = m_umlDoc->url();
QString fileName = url.fileName();
fileName.remove(QRegExp(".xmi$"));
url.setFileName(fileName);
uDebug() << "Exporting to directory: " << url;
return generateXhtmlForProjectInto(url);
}
void KexiProjectTitleSelectionPage::updateUrl()
{
KUrl url = contents->file_requester->url();
QString fn = KexiDB::string2FileName(contents->le_title->text());
if (!fn.isEmpty() && !fn.endsWith(".kexi"))
fn += ".kexi";
url.setFileName(fn);
contents->file_requester->setUrl(url);
}
/**
* Exports the current model to docbook in a directory named as the model
* with the .xmi suffix removed. The docbook file will have the same name
* with the .docbook suffix. Figures will be named as the corresponding
* diagrams in the GUI
* @todo change file naming to avoid paths with spaces or non-ASCII chars
* @todo better handling of error conditions
* @return true if saving is successful and false otherwise.
*/
bool DocbookGenerator::generateDocbookForProject()
{
KUrl url = umlDoc->url();
QString fileName = url.fileName();
fileName.remove(QRegExp(".xmi$"));
url.setFileName(fileName);
uDebug() << "Exporting to directory: " << url;
generateDocbookForProjectInto(url);
return true;
}
bool CvsProxy::isValidDirectory(KUrl dirPath) const
{
QFileInfo fsObject( dirPath.toLocalFile() );
if( !fsObject.isDir() )
dirPath.setFileName( QString() );
dirPath.addPath( "CVS" );
fsObject.setFile( dirPath.toLocalFile() );
return fsObject.exists();
}
KUrl OutputDirectory::changeExtension( const KUrl& url, const QString& extension )
{
KUrl newUrl = url;
QString fileName = newUrl.fileName();
fileName = newUrl.fileName().left( newUrl.fileName().lastIndexOf(".")+1 ) + extension;
newUrl.setFileName( fileName );
return newUrl;
}
/* The absolute URL of the item (if it is a directory), or its parent (if
it is a file).
*/
KUrl ScanGallery::itemDirectory(const FileTreeViewItem *item) const
{
if (item==NULL)
{
kDebug() << "no item";
return (KUrl());
}
KUrl u = item->url();
if (!item->isDir()) u.setFileName(""); // not a directory, remove file name
else u.adjustPath(KUrl::AddTrailingSlash); // is a directory, ensure ends with "/"
return (u);
}
KUrl OutputDirectory::uniqueFileName( const KUrl& url, const QStringList& usedOutputNames )
{
KUrl uniqueUrl = url;
while( QFile::exists(uniqueUrl.toLocalFile()) || usedOutputNames.contains(uniqueUrl.toLocalFile()) )
{
QString fileName = uniqueUrl.fileName();
fileName = fileName.left( fileName.lastIndexOf(".")+1 ) + i18nc("will be appended to the filename if a file with the same name already exists","new") + fileName.mid( fileName.lastIndexOf(".") );
uniqueUrl.setFileName( fileName );
}
return uniqueUrl;
}
void KexiStartupFileHandler::saveRecentDir()
{
if (!d->recentDirClass.isEmpty()) {
kDebug() << d->recentDirClass;
KUrl dirUrl;
if (d->requester)
dirUrl = d->requester->url();
else if (d->dialog)
dirUrl = d->dialog->selectedUrl();
kDebug() << dirUrl;
if (dirUrl.isValid() && dirUrl.isLocalFile()) {
dirUrl.setFileName(QString());
kDebug() << "Added" << dirUrl.url() << "to recent dirs class" << d->recentDirClass;
KRecentDirs::add(d->recentDirClass, dirUrl.url());
}
}
}
KUrl Kopete::Transfer::displayURL( const Kopete::Contact *contact, const QString &file )
{
KUrl url;
url.setProtocol( QString::fromLatin1("kopete") );
QString host;
if( !contact )
host = QString::fromLatin1("unknown origin");
else if( contact->metaContact() )
host = contact->metaContact()->displayName();
else
host = contact->contactId();
url.setHost(host);
// url.setPath( contact->protocol()->displayName() );
url.setFileName( file );
return url;
}
/* ----------------------------------------------------------------------- */
void ScanGallery::slotCreateFolder( )
{
bool ok;
QString folder = KInputDialog::getText( i18n( "New Folder" ),
i18n( "Name for the new folder:" ), QString::null,
&ok, this );
if( ok )
{
/* KIO create folder goes here */
FileTreeViewItem *it = highlightedFileTreeViewItem();
if( it )
{
KUrl url = it->url();
/* If a directory is selected, the filename needs not to be deleted */
if( ! it->isDir())
url.setFileName( "" );
/* add the folder name from user input */
url.addPath( folder );
kDebug() << "Creating folder" << url;
/* Since the new directory arrives in the packager in the newItems-slot, we set a
* variable urlToSelectOnArrive here. The newItems-slot will honor it and select
* the treeviewitem with that url.
*/
slotSetNextUrlToSelect( url );
if( ! KIO::NetAccess::mkdir( url, 0, -1 ))
{
kDebug() << "Error: creation of" << url << "failed!";
}
else
{
/* created successfully */
/* open the branch if necessary and select the new folder */
}
}
}
}
bool CvsProxy::isVersionControlled(KUrl filePath) const
{
QFileInfo fsObject( filePath.toLocalFile() );
if( !fsObject.isDir() )
filePath.setFileName( QString() );
filePath.addPath( "CVS" );
QFileInfo cvsObject( filePath.toLocalFile() );
if( !cvsObject.exists() )
return false;
if( fsObject.isDir() )
return true;
filePath.addPath( "Entries" );
QFile cvsEntries( filePath.toLocalFile() );
cvsEntries.open( QIODevice::ReadOnly );
QString cvsEntriesData = cvsEntries.readAll();
cvsEntries.close();
return ( cvsEntriesData.indexOf( fsObject.fileName() ) != -1 );
}
void renameImportedUrl(const KUrl& src)
{
KUrl dst = src;
dst.cd("..");
QString fileName;
if (mFileNameFormater.get()) {
KFileItem item(KFileItem::Unknown, KFileItem::Unknown, src, true /* delayedMimeTypes */);
// Get the document time, but do not cache the result because the
// 'src' url is temporary: if we import "foo/image.jpg" and
// "bar/image.jpg", both images will be temporarily saved in the
// 'src' url.
KDateTime dateTime = TimeUtils::dateTimeForFileItem(item, TimeUtils::SkipCache);
fileName = mFileNameFormater->format(src, dateTime);
} else {
fileName = src.fileName();
}
dst.setFileName(fileName);
FileUtils::RenameResult result = FileUtils::rename(src, dst, mAuthWindow);
switch (result) {
case FileUtils::RenamedOK:
mImportedUrlList << mCurrentUrl;
break;
case FileUtils::RenamedUnderNewName:
mRenamedCount++;
mImportedUrlList << mCurrentUrl;
break;
case FileUtils::Skipped:
mSkippedUrlList << mCurrentUrl;
break;
case FileUtils::RenameFailed:
kWarning() << "Rename failed for" << mCurrentUrl;
}
q->advance();
importNext();
}
QString Theme::internalName() const {
KUrl url = d->mUrl;
url.setFileName("");
return url.fileName();
}
bool AudioPlayerPrivate::play( const SoundInfo& si )
{
kDebug() ;
PlayData * data = new PlayData();
data->m_output = new Phonon::AudioOutput( Phonon::NotificationCategory );
data->m_output->setVolume( si.volume );
data->m_mediaobject = new Phonon::MediaObject();
Phonon::createPath(data->m_mediaobject, data->m_output);
data->m_info = si;
bool valid = false;
switch ( si.sound->soundType() )
{
case Sound::External:
{
QString url = si.sound->url();
kDebug(OkularDebug) << "External," << url;
if ( !url.isEmpty() )
{
int newid = newId();
m_mapper.setMapping( data->m_mediaobject, newid );
KUrl newurl;
if ( KUrl::isRelativeUrl( url ) )
{
newurl = m_currentDocument;
newurl.setFileName( url );
}
else
{
newurl = url;
}
data->m_mediaobject->setCurrentSource( newurl );
m_playing.insert( newid, data );
valid = true;
}
break;
}
case Sound::Embedded:
{
QByteArray filedata = si.sound->data();
kDebug(OkularDebug) << "Embedded," << filedata.length();
if ( !filedata.isEmpty() )
{
kDebug(OkularDebug) << "Mediaobject:" << data->m_mediaobject;
int newid = newId();
m_mapper.setMapping( data->m_mediaobject, newid );
data->m_buffer = new QBuffer();
data->m_buffer->setData( filedata );
data->m_mediaobject->setCurrentSource( Phonon::MediaSource( data->m_buffer ) );
m_playing.insert( newid, data );
valid = true;
}
break;
}
}
if ( !valid )
{
delete data;
data = 0;
}
if ( data )
{
QObject::connect( data->m_mediaobject, SIGNAL(finished()), &m_mapper, SLOT(map()) );
kDebug(OkularDebug) << "PLAY";
data->play();
m_state = AudioPlayer::PlayingState;
}
return valid;
}
bool EnfuseFinalTask::startEnfuse(const KUrl::List& inUrls, KUrl& outUrl,
const EnfuseSettings& settings,
const QString& enfusePath, QString& errors)
{
QString comp;
QString ext = KPSaveSettingsWidget::extensionForFormat(settings.outputFormat);
if (ext == QString(".tif"))
comp = QString("--compression=DEFLATE");
outUrl.setFileName(QString(".kipi-expoblending-tmp-") + QString::number(QDateTime::currentDateTime().toTime_t()) + ext);
enfuseProcess = new KProcess;
enfuseProcess->clearProgram();
enfuseProcess->setOutputChannelMode(KProcess::MergedChannels);
QStringList args;
args << enfusePath;
if (!settings.autoLevels)
{
args << "-l";
args << QString::number(settings.levels);
}
if (settings.ciecam02)
args << "-c";
if (!comp.isEmpty())
args << comp;
if (settings.hardMask)
{
if (enfuseVersion4x)
args << "--hard-mask";
else
args << "--HardMask";
}
if (enfuseVersion4x)
{
args << QString("--exposure-weight=%1").arg(settings.exposure);
args << QString("--saturation-weight=%1").arg(settings.saturation);
args << QString("--contrast-weight=%1").arg(settings.contrast);
}
else
{
args << QString("--wExposure=%1").arg(settings.exposure);
args << QString("--wSaturation=%1").arg(settings.saturation);
args << QString("--wContrast=%1").arg(settings.contrast);
}
args << "-v";
args << "-o";
args << outUrl.toLocalFile();
foreach(const KUrl& url, inUrls)
args << url.toLocalFile();
enfuseProcess->setProgram(args);
kDebug() << "Enfuse command line: " << enfuseProcess->program();
enfuseProcess->start();
if (!enfuseProcess->waitForFinished(-1))
{
successFlag = false;
errors = getProcessError(enfuseProcess);
return false;
}
kDebug() << "Enfuse output url: " << outUrl;
kDebug() << "Enfuse exit status: " << enfuseProcess->exitStatus();
kDebug() << "Enfuse exit code: " << enfuseProcess->exitCode();
if (enfuseProcess->exitStatus() != QProcess::NormalExit)
{
successFlag = false;
return false;
}
if (enfuseProcess->exitCode() == 0)
{
// Process finished successfully !
return true;
}
errors = getProcessError(enfuseProcess);
successFlag = false;
return false;
}
bool KShortUriFilter::filterUri( KUriFilterData& data ) const
{
/*
* Here is a description of how the shortURI deals with the supplied
* data. First it expands any environment variable settings and then
* deals with special shortURI cases. These special cases are the "smb:"
* URL scheme which is very specific to KDE, "#" and "##" which are
* shortcuts for man:/ and info:/ protocols respectively. It then handles
* local files. Then it checks to see if the URL is valid and one that is
* supported by KDE's IO system. If all the above checks fails, it simply
* lookups the URL in the user-defined list and returns without filtering
* if it is not found. TODO: the user-defined table is currently only manually
* hackable and is missing a config dialog.
*/
KUrl url = data.uri();
QString cmd = data.typedString();
// WORKAROUND: Allow the use of '@' in the username component of a URL since
// other browsers such as firefox in their infinite wisdom allow such blatant
// violations of RFC 3986. BR# 69326/118413.
if (cmd.count(QLatin1Char('@')) > 1) {
const int lastIndex = cmd.lastIndexOf(QLatin1Char('@'));
// Percent encode all but the last '@'.
QString encodedCmd = QUrl::toPercentEncoding(cmd.left(lastIndex), ":/");
encodedCmd += cmd.mid(lastIndex);
KUrl u (encodedCmd);
if (u.isValid()) {
cmd = encodedCmd;
url = u;
}
}
const bool isMalformed = !url.isValid();
QString protocol = url.protocol();
kDebug(7023) << cmd;
// Fix misparsing of "foo:80", QUrl thinks "foo" is the protocol and "80" is the path.
// However, be careful not to do that for valid hostless URLs, e.g. file:///foo!
if (!protocol.isEmpty() && url.host().isEmpty() && !url.path().isEmpty()
&& cmd.contains(':') && !KProtocolInfo::protocols().contains(protocol)) {
protocol.clear();
}
//kDebug(7023) << "url=" << url << "cmd=" << cmd << "isMalformed=" << isMalformed;
if (!isMalformed &&
(protocol.length() == 4) &&
(protocol != QLatin1String("http")) &&
(protocol[0]=='h') &&
(protocol[1]==protocol[2]) &&
(protocol[3]=='p'))
{
// Handle "encrypted" URLs like: h++p://www.kde.org
url.setProtocol( QLatin1String("http"));
setFilteredUri( data, url);
setUriType( data, KUriFilterData::NetProtocol );
return true;
}
// TODO: Make this a bit more intelligent for Minicli! There
// is no need to make comparisons if the supplied data is a local
// executable and only the argument part, if any, changed! (Dawit)
// You mean caching the last filtering, to try and reuse it, to save stat()s? (David)
const QString starthere_proto = QL1S("start-here:");
if (cmd.indexOf(starthere_proto) == 0 )
{
setFilteredUri( data, KUrl("system:/") );
setUriType( data, KUriFilterData::LocalDir );
return true;
}
// Handle MAN & INFO pages shortcuts...
const QString man_proto = QL1S("man:");
const QString info_proto = QL1S("info:");
if( cmd[0] == '#' ||
cmd.indexOf( man_proto ) == 0 ||
cmd.indexOf( info_proto ) == 0 )
{
if( cmd.left(2) == QL1S("##") )
cmd = QL1S("info:/") + cmd.mid(2);
else if ( cmd[0] == '#' )
cmd = QL1S("man:/") + cmd.mid(1);
else if ((cmd==info_proto) || (cmd==man_proto))
cmd+='/';
setFilteredUri( data, KUrl( cmd ));
setUriType( data, KUriFilterData::Help );
return true;
}
// Detect UNC style (aka windows SMB) URLs
if ( cmd.startsWith( QLatin1String( "\\\\") ) )
{
// make sure path is unix style
cmd.replace('\\', '/');
cmd.prepend( QLatin1String( "smb:" ) );
setFilteredUri( data, KUrl( cmd ));
setUriType( data, KUriFilterData::NetProtocol );
return true;
}
bool expanded = false;
// Expanding shortcut to HOME URL...
QString path;
QString ref;
QString query;
QString nameFilter;
if (KUrl::isRelativeUrl(cmd) && QDir::isRelativePath(cmd)) {
path = cmd;
//kDebug(7023) << "path=cmd=" << path;
} else {
if (url.isLocalFile())
{
//kDebug(7023) << "hasRef=" << url.hasRef();
// Split path from ref/query
// but not for "/tmp/a#b", if "a#b" is an existing file,
// or for "/tmp/a?b" (#58990)
if( ( url.hasRef() || !url.query().isEmpty() )
&& !url.path().endsWith(QL1S("/")) ) // /tmp/?foo is a namefilter, not a query
{
path = url.path();
ref = url.ref();
//kDebug(7023) << "isLocalFile set path to " << stringDetails( path );
//kDebug(7023) << "isLocalFile set ref to " << stringDetails( ref );
query = url.query();
if (path.isEmpty() && url.hasHost())
path = '/';
}
else
{
path = cmd;
//kDebug(7023) << "(2) path=cmd=" << path;
}
}
}
if( path[0] == '~' )
{
int slashPos = path.indexOf('/');
if( slashPos == -1 )
slashPos = path.length();
if( slashPos == 1 ) // ~/
{
path.replace ( 0, 1, QDir::homePath() );
}
else // ~username/
{
const QString userName (path.mid( 1, slashPos-1 ));
KUser user (userName);
if( user.isValid() && !user.homeDir().isEmpty())
{
path.replace (0, slashPos, user.homeDir());
}
else
{
if (user.isValid()) {
setErrorMsg(data, i18n("<qt><b>%1</b> does not have a home folder.</qt>", userName));
} else {
setErrorMsg(data, i18n("<qt>There is no user called <b>%1</b>.</qt>", userName));
}
setUriType( data, KUriFilterData::Error );
// Always return true for error conditions so
// that other filters will not be invoked !!
return true;
}
}
expanded = true;
}
else if ( path[0] == '$' ) {
// Environment variable expansion.
if ( sEnvVarExp.indexIn( path ) == 0 )
{
QByteArray exp = qgetenv( path.mid( 1, sEnvVarExp.matchedLength() - 1 ).toLocal8Bit().data() );
if(! exp.isNull())
{
path.replace( 0, sEnvVarExp.matchedLength(), QString::fromLocal8Bit(exp.constData()) );
expanded = true;
}
}
}
if ( expanded || cmd.startsWith( '/' ) )
{
// Look for #ref again, after $ and ~ expansion (testcase: $QTDIR/doc/html/functions.html#s)
// Can't use KUrl here, setPath would escape it...
const int pos = path.indexOf('#');
if ( pos > -1 )
{
const QString newPath = path.left( pos );
if ( QFile::exists( newPath ) )
{
ref = path.mid( pos + 1 );
path = newPath;
//kDebug(7023) << "Extracted ref: path=" << path << " ref=" << ref;
}
}
}
bool isLocalFullPath = (!path.isEmpty() && path[0] == '/');
// Checking for local resource match...
// Determine if "uri" is an absolute path to a local resource OR
// A local resource with a supplied absolute path in KUriFilterData
const QString abs_path = data.absolutePath();
const bool canBeAbsolute = (protocol.isEmpty() && !abs_path.isEmpty());
const bool canBeLocalAbsolute = (canBeAbsolute && abs_path[0] =='/' && !isMalformed);
bool exists = false;
/*kDebug(7023) << "abs_path=" << abs_path
<< "protocol=" << protocol
<< "canBeAbsolute=" << canBeAbsolute
<< "canBeLocalAbsolute=" << canBeLocalAbsolute
<< "isLocalFullPath=" << isLocalFullPath;*/
KDE_struct_stat buff;
if ( canBeLocalAbsolute )
{
QString abs = QDir::cleanPath( abs_path );
// combine absolute path (abs_path) and relative path (cmd) into abs_path
int len = path.length();
if( (len==1 && path[0]=='.') || (len==2 && path[0]=='.' && path[1]=='.') )
path += '/';
//kDebug(7023) << "adding " << abs << " and " << path;
abs = QDir::cleanPath(abs + '/' + path);
//kDebug(7023) << "checking whether " << abs << " exists.";
// Check if it exists
if( KDE::stat( abs, &buff ) == 0 )
{
path = abs; // yes -> store as the new cmd
exists = true;
isLocalFullPath = true;
}
}
if (isLocalFullPath && !exists && !isMalformed) {
exists = ( KDE::stat( path, &buff ) == 0 );
if ( !exists ) {
// Support for name filter (/foo/*.txt), see also KonqMainWindow::detectNameFilter
// If the app using this filter doesn't support it, well, it'll simply error out itself
int lastSlash = path.lastIndexOf( '/' );
if ( lastSlash > -1 && path.indexOf( ' ', lastSlash ) == -1 ) // no space after last slash, otherwise it's more likely command-line arguments
{
QString fileName = path.mid( lastSlash + 1 );
QString testPath = path.left( lastSlash + 1 );
if ( ( fileName.indexOf( '*' ) != -1 || fileName.indexOf( '[' ) != -1 || fileName.indexOf( '?' ) != -1 )
&& KDE::stat( testPath, &buff ) == 0 )
{
nameFilter = fileName;
//kDebug(7023) << "Setting nameFilter to " << nameFilter;
path = testPath;
exists = true;
}
}
}
}
//kDebug(7023) << "path =" << path << " isLocalFullPath=" << isLocalFullPath << " exists=" << exists;
if( exists )
{
KUrl u;
u.setPath(path);
//kDebug(7023) << "ref=" << stringDetails(ref) << " query=" << stringDetails(query);
u.setRef(ref);
u.setQuery(query);
if (!KAuthorized::authorizeUrlAction( QLatin1String("open"), KUrl(), u))
{
// No authorization, we pretend it's a file will get
// an access denied error later on.
setFilteredUri( data, u );
setUriType( data, KUriFilterData::LocalFile );
return true;
}
// Can be abs path to file or directory, or to executable with args
bool isDir = S_ISDIR( buff.st_mode );
if( !isDir && access ( QFile::encodeName(path).data(), X_OK) == 0 )
{
//kDebug(7023) << "Abs path to EXECUTABLE";
setFilteredUri( data, u );
setUriType( data, KUriFilterData::Executable );
return true;
}
// Open "uri" as file:/xxx if it is a non-executable local resource.
if( isDir || S_ISREG( buff.st_mode ) )
{
//kDebug(7023) << "Abs path as local file or directory";
if ( !nameFilter.isEmpty() )
u.setFileName( nameFilter );
setFilteredUri( data, u );
setUriType( data, ( isDir ) ? KUriFilterData::LocalDir : KUriFilterData::LocalFile );
return true;
}
// Should we return LOCAL_FILE for non-regular files too?
kDebug(7023) << "File found, but not a regular file nor dir... socket?";
}
if( data.checkForExecutables())
{
// Let us deal with possible relative URLs to see
// if it is executable under the user's $PATH variable.
// We try hard to avoid parsing any possible command
// line arguments or options that might have been supplied.
QString exe = removeArgs( cmd );
//kDebug(7023) << "findExe with" << exe;
if (!KStandardDirs::findExe( exe ).isNull() )
{
//kDebug(7023) << "EXECUTABLE exe=" << exe;
setFilteredUri( data, KUrl::fromPath( exe ));
// check if we have command line arguments
if( exe != cmd )
setArguments(data, cmd.right(cmd.length() - exe.length()));
setUriType( data, KUriFilterData::Executable );
return true;
}
}
// Process URLs of known and supported protocols so we don't have
// to resort to the pattern matching scheme below which can possibly
// slow things down...
if ( !isMalformed && !isLocalFullPath && !protocol.isEmpty() )
{
//kDebug(7023) << "looking for protocol " << protocol;
if ( KProtocolInfo::isKnownProtocol( protocol ) )
{
setFilteredUri( data, url );
if ( protocol == QL1S("man") || protocol == QL1S("help") )
setUriType( data, KUriFilterData::Help );
else
setUriType( data, KUriFilterData::NetProtocol );
return true;
}
}
// Short url matches
if ( !cmd.contains( ' ' ) )
{
// Okay this is the code that allows users to supply custom matches for
// specific URLs using Qt's regexp class. This is hard-coded for now.
// TODO: Make configurable at some point...
Q_FOREACH(const URLHint& hint, m_urlHints)
{
if (hint.regexp.indexIn(cmd) == 0)
{
//kDebug(7023) << "match - prepending" << (*it).prepend;
const QString cmdStr = hint.prepend + cmd;
KUrl url(cmdStr);
if (KProtocolInfo::isKnownProtocol(url))
{
setFilteredUri( data, url );
setUriType( data, hint.type );
return true;
}
}
}
// No protocol and not malformed means a valid short URL such as kde.org or
// [email protected]. However, it might also be valid only because it lacks
// the scheme component, e.g. www.kde,org (illegal ',' before 'org'). The
// check below properly deciphers the difference between the two and sends
// back the proper result.
if (protocol.isEmpty() && isPotentialShortURL(cmd))
{
QString urlStr = data.defaultUrlScheme();
if (urlStr.isEmpty())
urlStr = m_strDefaultUrlScheme;
const int index = urlStr.indexOf(QL1C(':'));
if (index == -1 || !KProtocolInfo::isKnownProtocol(urlStr.left(index)))
urlStr += QL1S("://");
urlStr += cmd;
KUrl url (urlStr);
if (url.isValid())
{
setFilteredUri(data, url);
setUriType(data, KUriFilterData::NetProtocol);
}
else if (KProtocolInfo::isKnownProtocol(url.protocol()))
{
setFilteredUri(data, data.uri());
setUriType(data, KUriFilterData::Error);
}
return true;
}
}
