//static
QPixmap KThumb::getImage(KUrl url, int frame, int width, int height)
{
Mlt::Profile profile(KdenliveSettings::current_profile().toUtf8().constData());
QPixmap pix(width, height);
if (url.isEmpty()) return pix;
//"<mlt><playlist><producer resource=\"" + url.path() + "\" /></playlist></mlt>");
//Mlt::Producer producer(profile, "xml-string", tmp);
Mlt::Producer *producer = new Mlt::Producer(profile, url.path().toUtf8().constData());
double swidth = (double) profile.width() / profile.height();
pix = QPixmap::fromImage(getFrame(producer, frame, (int) (height * swidth + 0.5), width, height));
delete producer;
return pix;
}
void GvCore::addUrlToRecentFolders(KUrl url)
{
if (!GwenviewConfig::historyEnabled()) {
return;
}
if (!url.isValid()) {
return;
}
if (url.path() != "") { // This check is a workaraound for bug #312060
url.adjustPath(KUrl::AddTrailingSlash);
}
recentFoldersModel();
d->mRecentFoldersModel->addUrl(url);
}
AmarokScriptCodeCompletionModel::AmarokScriptCodeCompletionModel( QObject *parent )
: CodeCompletionModel( parent )
{
const KUrl url( KStandardDirs::locate( "data", "amarok/scriptconsole/" ) );
QFile file( url.path() + "AutoComplete.txt" );
if( file.open( QFile::ReadOnly ) )
{
QTextStream in( &file );
while ( !in.atEnd() )
m_autoCompleteStrings << in.readLine();
}
else
debug() << "No autocomplete file found for the script console";
}
void Adb::stat( const KUrl& url )
{
qDebug() << "Entering function adb::stat(" << url.path() << ")";
try {
UDSEntry entry=this->getEntry(url);
this->statEntry(entry);
this->finished();
} catch(QString &errorMessage) {
qDebug() << "exception: " << errorMessage;
QStringList strLines = errorMessage.split("|");
this->error(strLines[0].toInt(), errorMessage);
}
}
void HistoryCollection::push(const KUrl &url) //slot
{
if (!url.isEmpty())
{
if (!m_receiver)
{
m_f->clear();
m_receiver = m_b;
}
m_receiver->push(url.path(KUrl::AddTrailingSlash));
}
m_receiver = 0;
}
void FileNameSearchProtocol::searchDirectory(const KUrl& directory)
{
// Don't try to iterate the pseudo filesystem directories of Linux
if (directory.path() == QLatin1String("/dev")
|| directory.path() == QLatin1String("/proc")
|| directory.path() == QLatin1String("/sys")) {
return;
}
// Get all items of the directory
KDirLister *dirLister = new KDirLister();
dirLister->setDelayedMimeTypes(false);
dirLister->setAutoErrorHandlingEnabled(false, 0);
dirLister->openUrl(directory);
QEventLoop eventLoop;
QObject::connect(dirLister, SIGNAL(canceled()), &eventLoop, SLOT(quit()));
QObject::connect(dirLister, SIGNAL(completed()), &eventLoop, SLOT(quit()));
eventLoop.exec();
// Visualize all items that match the search pattern
QList<KUrl> pendingDirs;
const KFileItemList items = dirLister->items();
foreach (const KFileItem& item, items) {
bool addItem = false;
if (!m_regExp || item.name().contains(*m_regExp)) {
addItem = true;
if (!m_checkType.isEmpty()) {
addItem = false;
const QStringList types = m_checkType.split(";");
const KSharedPtr<KMimeType> mime = item.determineMimeType();
foreach (const QString& t, types) {
if (mime->is(t)) {
addItem = true;
}
}
}
void BatchDialog::addItems(const KUrl::List& itemList)
{
QString ext;
switch(d->saveSettingsBox->fileFormat())
{
case SaveSettingsWidget::OUTPUT_JPEG:
ext = "jpg";
break;
case SaveSettingsWidget::OUTPUT_TIFF:
ext = "tif";
break;
case SaveSettingsWidget::OUTPUT_PPM:
ext = "ppm";
break;
case SaveSettingsWidget::OUTPUT_PNG:
ext = "png";
break;
}
KUrl::List urlList;
QPixmap pix(SmallIcon("image-x-generic", KIconLoader::SizeLarge, KIconLoader::DisabledState));
for (KUrl::List::const_iterator it = itemList.begin();
it != itemList.end(); ++it)
{
KUrl url = *it;
QFileInfo fi(url.path());
if (fi.exists() && !findItem(url))
{
QString dest = fi.baseName() + QString(".") + ext;
new CListViewItem(d->listView, pix, url, dest);
urlList.append(url);
}
}
if (!urlList.empty())
{
if (!d->iface->hasFeature(KIPI::HostSupportsThumbnails))
d->thread->thumbRawFiles(urlList);
else
d->iface->thumbnails(urlList, 256);
d->thread->identifyRawFiles(urlList);
if (!d->thread->isRunning())
d->thread->start();
}
}
bool LeaveItemHandler::openUrl(const KUrl& url)
{
m_logoutAction = url.path().remove('/');
if (m_logoutAction == "sleep") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(suspendRAM()));
return true;
} else if (m_logoutAction == "hibernate") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(suspendDisk()));
return true;
} else if (m_logoutAction == "lock") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(lock()));
return true;
} else if (m_logoutAction == "switch") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(switchUser()));
return true;
} else if (m_logoutAction == "logout" || m_logoutAction == "logoutonly" ||
m_logoutAction == "restart" || m_logoutAction == "shutdown") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(logout()));
return true;
} else if (m_logoutAction == "savesession") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(saveSession()));
return true;
} else if (m_logoutAction == "standby") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(standby()));
return true;
} else if (m_logoutAction == "suspendram") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(suspendRAM()));
return true;
} else if (m_logoutAction == "suspenddisk") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(suspendDisk()));
return true;
} else if (m_logoutAction == "run") {
// decouple dbus call, otherwise we'll run into a dead-lock
QTimer::singleShot(0, this, SLOT(runCommand()));
return true;
}
return false;
}
QVariantHash ChooseSamba::values() const
{
QVariantHash ret = m_args;
QString address = ui->addressLE->text().trimmed();
KUrl url;
if (address.startsWith(QLatin1String("//"))) {
url = QLatin1String("smb:") % address;
} else if (address.startsWith(QLatin1String("/"))) {
url = QLatin1String("smb:/") % address;
} else if (address.startsWith(QLatin1String("://"))) {
url = QLatin1String("smb") % address;
} else if (address.startsWith(QLatin1String("smb://"))) {
url = address;
} else if (!KUrl(address).protocol().isEmpty() &&
KUrl(address).protocol() != QLatin1String("smb")) {
url = address;
url.setProtocol(QLatin1String("smb"));
} else {
url = QLatin1String("smb://") % address;
}
kDebug() << 1 << url;
if (!ui->usernameLE->text().isEmpty()) {
url.setUser(ui->usernameLE->text());
}
if (!ui->passwordLE->text().isEmpty()) {
url.setPass(ui->passwordLE->text());
}
kDebug() << 2 << url;
kDebug() << 3 << url.url() << url.path().section(QLatin1Char('/'), -1, -1);// same as url.fileName()
kDebug() << 4 << url.fileName();
kDebug() << 5 << url.host() << url.url().section(QLatin1Char('/'), 3, 3).toLower();
ret[KCUPS_DEVICE_URI] = url.url();
ret[KCUPS_DEVICE_INFO] = url.fileName();
// if there is 4 '/' means the url is like
// smb://group/host/printer, so the location is at a different place
if (url.url().count(QLatin1Char('/') == 4)) {
ret[KCUPS_DEVICE_LOCATION] = url.url().section(QLatin1Char('/'), 3, 3).toLower();
} else {
ret[KCUPS_DEVICE_LOCATION] = url.host();
}
return ret;
}
// The opposite of parseURL
static QString splitURL( int mRealArgType, const KUrl& url )
{
if ( mRealArgType == 33 ) { // LDAP server
// The format is HOSTNAME:PORT:USERNAME:PASSWORD:BASE_DN
Q_ASSERT( url.protocol() == "ldap" );
return urlpart_encode( url.host() ) + ':' +
( url.port() != -1 ? QString::number( url.port() ) : QString() ) + ':' + // -1 is used for default ports, omit
urlpart_encode( url.user() ) + ':' +
urlpart_encode( url.pass() ) + ':' +
// KUrl automatically encoded the query (e.g. for spaces inside it),
// so decode it before writing it out to gpgconf (issue119)
urlpart_encode( KUrl::fromPercentEncoding( url.query().mid(1).toLatin1() ) );
}
return url.path();
}
UDSEntry Adb::getEntry( const KUrl& url )
{
QStringList arguments;
arguments << "shell";
QString path=this->fillArguments(url.path(), arguments);
arguments << "ls";
arguments << "-la"; // hidden files
arguments << path ; // FIXME: escape ?????
QByteArray read_stdout, read_stderr;
int rc=this->exec(arguments, read_stdout, read_stderr);
qDebug() << "-------------------------- ls -la " << (path+"") << " rc=" << rc << " -------------------";
QStringList fileLines = QString(read_stdout).split("\n");
QString lineFull=this->removeNewline(fileLines[0]);
return this->getEntry(lineFull);
}
bool baseMatch(const KUrl &url, const QString &protClass) const
{
if (baseProtWildCard)
{
if ( !baseProt.isEmpty() && !url.protocol().startsWith(baseProt) &&
(protClass.isEmpty() || (protClass != baseProt)) )
return false;
}
else
{
if ( (url.protocol() != baseProt) &&
(protClass.isEmpty() || (protClass != baseProt)) )
return false;
}
if (baseHostWildCard)
{
if (!baseHost.isEmpty() && !url.host().endsWith(baseHost))
return false;
}
else
{
if (url.host() != baseHost)
return false;
}
if (basePathWildCard)
{
if (!basePath.isEmpty() && !url.path().startsWith(basePath))
return false;
}
else
{
if (url.path() != basePath)
return false;
}
return true;
}
QString
PixmapCollection::addPixmapPath(const KUrl &url)
{
QString name = url.filename();
while (m_pixmaps.contains(name)) {
bool ok;
int num = name.right(1).toInt(&ok, 10);
if (ok)
name = name.left(name.length() - 1) + QString::number(num + 1);
else
name += "2";
}
m_pixmaps.insert(name, qMakePair(url.path(), 0));
return name;
}
void Editor::loadBoard()
{
if (!testSave()) {
return;
}
KUrl url = KFileDialog::getOpenUrl(KUrl(), i18n("*.layout|Board Layout (*.layout)\n*|All File"
"s"), this, i18n("Open Board Layout"));
if (url.isEmpty()) {
return;
}
theBoard.loadBoardLayout(url.path());
update();
}
KoFilterChooser::KoFilterChooser(QWidget *parent, const QStringList &mimeTypes, const QString &nativeFormat, const KUrl &url)
: KDialog(parent),
m_mimeTypes(mimeTypes)
{
setObjectName("kofilterchooser");
setInitialSize(QSize(300, 350));
setButtons(KDialog::Ok|KDialog::Cancel);
setDefaultButton(KDialog::Ok);
setCaption(i18n("Choose Filter"));
setModal(true);
QWidget *page = new QWidget(this);
setMainWidget(page);
QVBoxLayout *layout = new QVBoxLayout(page);
if (url.isValid()) {
KSqueezedTextLabel *l = new KSqueezedTextLabel(url.path(), page);
layout->addWidget(l);
}
m_filterList = new QListWidget(page);
layout->addWidget(m_filterList);
page->setLayout(layout);
Q_ASSERT(!m_mimeTypes.isEmpty());
for (QStringList::ConstIterator it = m_mimeTypes.constBegin();
it != m_mimeTypes.constEnd();
it++) {
KMimeType::Ptr mime = KMimeType::mimeType(*it);
const QString name = mime ? mime->comment() : *it;
if (! name.isEmpty())
m_filterList->addItem(name);
}
if (nativeFormat == "application/x-kword") {
const int index = m_mimeTypes.indexOf("text/plain");
if (index > -1)
m_filterList->setCurrentRow(index);
}
if (m_filterList->currentRow() == -1)
m_filterList->setCurrentRow(0);
m_filterList->setFocus();
connect(m_filterList, SIGNAL(itemDoubleClicked(QListWidgetItem*)), this, SLOT(accept()));
resize(QSize(520, 400));//.expandedTo(minimumSizeHint()));
}
void Nepomuk2::TvshowProtocol::stat( const KUrl& url )
{
// for basic functionality we only need to stat the folders
const QStringList pathTokens = url.path().split('/', QString::SkipEmptyParts);
if(pathTokens.count() == 1 && pathTokens.first() == QLatin1String("latest")) {
KIO::UDSEntry uds = createFolderUDSEntry(QLatin1String("latest"), i18n("Next Episodes To Watch"));
uds.insert(KIO::UDSEntry::UDS_ICON_NAME, QLatin1String("favorites"));
statEntry(uds);
finished();
}
else if(pathTokens.count() == 1) {
// stat series folder
Soprano::QueryResultIterator it
= Nepomuk2::ResourceManager::instance()->mainModel()->executeQuery(QString::fromLatin1("select distinct * where { "
"?r a nmm:TVSeries ; "
"nie:title %1 ; "
"nao:created ?cd ; "
"nao:lastModified ?md ; "
"nie:description ?d . } LIMIT 1")
.arg(Soprano::Node::literalToN3(pathTokens[0])),
Soprano::Query::QueryLanguageSparql);
if(it.next()) {
statEntry(createSeriesUDSEntry(it["r"].uri(),
pathTokens[0],
pathTokens[0],
it["d"].toString(),
it["cd"].literal().toDateTime(),
it["md"].literal().toDateTime()));
finished();
}
else {
error( ERR_DOES_NOT_EXIST, url.prettyUrl() );
}
}
else if(pathTokens.count() == 2) {
// stat season folder
statEntry(createFolderUDSEntry(pathTokens[0], pathTokens[1]));
finished();
}
else {
// FIXME
error( ERR_UNSUPPORTED_ACTION, url.prettyUrl() );
}
}
void KShellCmdPlugin::slotExecuteShellCommand()
{
KParts::ReadOnlyPart * part = dynamic_cast<KParts::ReadOnlyPart *>(parent());
if ( !part )
{
KMessageBox::sorry(0L, i18n("KShellCmdPlugin::slotExecuteShellCommand: Program error, please report a bug."));
return;
}
KUrl url = KIO::NetAccess::mostLocalUrl(part->url(),NULL);
if ( !url.isLocalFile() )
{
KMessageBox::sorry(part->widget(),i18n("Executing shell commands works only on local directories."));
return;
}
QString path;
#if 0 // to be ported if still needed
if ( part->currentItem() )
{
// Putting the complete path to the selected file isn't really necessary,
// since we'll cd to the directory first. But we do need to get the
// complete relative path.
path = KUrl::relativePath( url.path(),
part->currentItem()->url().path() );
}
else
#endif
{
path = url.toLocalFile();
}
bool ok;
QString cmd = KInputDialog::getText( i18nc("@title:window", "Execute Shell Command"),
i18n( "Execute shell command in current directory:" ),
KShell::quoteArg( path ), &ok, part->widget() );
if ( ok )
{
QString chDir;
chDir="cd ";
chDir+=KShell::quoteArg(part->url().path());
chDir+="; ";
chDir+=cmd;
KShellCommandDialog *shellCmdDialog=new KShellCommandDialog(i18n("Output from command: \"%1\"", cmd),chDir,part->widget(),true);
shellCmdDialog->resize(500,300);
shellCmdDialog->executeCommand();
delete shellCmdDialog;
}
}
// static function
ContextHelp::LinkType ContextHelp::extractLinkType( const KUrl & url )
{
QString path = url.path();
if ( url.protocol() == "ktechlab-help" )
{
if ( itemLibrary()->haveDescription( path, KGlobal::locale()->language() ) )
return HelpLink;
else
return NewHelpLink;
}
if ( url.protocol() == "ktechlab-example" )
return ExampleLink;
return ExternalLink;
}
void GroupwareDownloadJob::slotItemDownloaded( const QString &localID,
const KUrl &remoteURL, const QString &fingerprint )
{
kDebug()<<"GroupwareDownloadJob::slotItemDownloaded(" << localID <<"," << remoteURL.url() <<"," << fingerprint <<")";
if ( mItemsForDownload.contains( remoteURL ) ) {
mItemsDownloaded[ remoteURL ] = mItemsForDownload[ remoteURL ];
mItemsForDownload.remove( remoteURL );
}
if ( mItemsDownloading.contains( remoteURL ) ) {
mItemsDownloaded[ remoteURL ] = mItemsDownloading[ remoteURL ];
mItemsDownloading.remove( remoteURL );
}
if ( !mItemsDownloaded.contains( remoteURL ) ) {
mItemsDownloaded[ remoteURL ] = KPIM::FolderLister::Unknown;
}
adaptor()->idMapper()->setRemoteId( localID, remoteURL.path() );
adaptor()->idMapper()->setFingerprint( localID, fingerprint );
}
MyImageData LoadImageData(const KUrl& urlToLoad)
{
MyImageData imageData;
imageData.url = urlToLoad;
// TODO: error handling!
KExiv2Iface::KExiv2 exiv2Iface;
exiv2Iface.load(urlToLoad.path());
double lat, lon, alt;
if (exiv2Iface.getGPSInfo(alt, lat, lon))
{
imageData.coordinates.setLatLon(lat, lon);
imageData.coordinates.setAlt(alt);
}
return imageData;
}
void JabberGroupMemberContact::sendFile ( const KUrl &sourceURL, const QString &/*fileName*/, uint /*fileSize*/ )
{
QString filePath;
// if the file location is null, then get it from a file open dialog
if ( !sourceURL.isValid () )
filePath = KFileDialog::getOpenFileName( KUrl(), "*", 0L, i18n ( "Kopete File Transfer" ) );
else
filePath = sourceURL.path(KUrl::RemoveTrailingSlash);
QFile file ( filePath );
if ( file.exists () )
{
// send the file
new JabberFileTransfer ( account (), this, filePath );
}
}
CJobRunner::Item::Item(const KUrl &u, const QString &n, bool dis)
: KUrl(u), name(n), fileName(Misc::getFile(u.path())), isDisabled(dis)
{
type=Misc::checkExt(fileName, "pfa") || Misc::checkExt(fileName, "pfb")
? TYPE1_FONT
: Misc::checkExt(fileName, "afm")
? TYPE1_AFM
: Misc::checkExt(fileName, "pfm")
? TYPE1_PFM
: OTHER_FONT;
if(OTHER_FONT!=type)
{
int pos(fileName.lastIndexOf('.'));
if(-1!=pos)
fileName=fileName.left(pos);
}
}
QString FileDialog::getSaveFileName(const KUrl& dir, const QString& filter, QWidget* parent, const QString& caption, bool* append)
{
bool defaultDir = dir.isEmpty();
bool specialDir = !defaultDir && dir.protocol() == "kfiledialog";
// Use AutoQPointer to guard against crash on application exit while
// the dialogue is still open. It prevents double deletion (both on
// deletion of parent, and on return from this function).
AutoQPointer<FileDialog> dlg = new FileDialog(specialDir ? dir : KUrl(), filter, parent);
if (!specialDir && !defaultDir)
{
if (!dir.isLocalFile())
kWarning() << "FileDialog::getSaveFileName called with non-local start dir " << dir;
dlg->setSelection(dir.isLocalFile() ? dir.toLocalFile() : dir.path()); // may also be a filename
}
dlg->setOperationMode(Saving);
dlg->setMode(KFile::File | KFile::LocalOnly);
dlg->setConfirmOverwrite(true);
if (!caption.isEmpty())
dlg->setCaption(caption);
mAppendCheck = 0;
if (append)
{
// Show an 'append' option in the dialogue.
// Note that the dialogue will take ownership of the QCheckBox.
mAppendCheck = new QCheckBox(i18nc("@option:check", "Append to existing file"), 0);
connect(mAppendCheck, SIGNAL(toggled(bool)), dlg, SLOT(appendToggled(bool)));
dlg->fileWidget()->setCustomWidget(mAppendCheck);
*append = false;
}
dlg->setWindowModality(Qt::WindowModal);
dlg->exec();
if (!dlg)
return QString(); // dialogue was deleted
QString filename = dlg->selectedFile();
if (!filename.isEmpty())
{
if (append)
*append = mAppendCheck->isChecked();
KRecentDocument::add(filename);
}
return filename;
}
void
FileBrowser::Private::readConfig()
{
const KUrl homeUrl( QDir::homePath() );
const KUrl savedUrl = Amarok::config( "File Browser" ).readEntry( "Current Directory", homeUrl );
bool useHome( true );
// fall back to $HOME if the saved dir has since disappeared or is a remote one
if( savedUrl.isLocalFile() )
{
QDir dir( savedUrl.path() );
if( dir.exists() )
useHome = false;
}
else if( KIO::NetAccess::exists( savedUrl, KIO::NetAccess::DestinationSide, 0 ) )
{
useHome = false;
}
currentPath = useHome ? homeUrl : savedUrl;
}
KUrl replaceVariablesUrl( const KUrl &url, const QString &email )
{
QString emailName;
QString emailHost;
const int atPos = email.indexOf( '@' );
if ( atPos >= 0 ) {
emailName = email.left( atPos );
emailHost = email.mid( atPos + 1 );
}
QString saveStr = url.path();
saveStr.replace( QRegExp( "%[Ee][Mm][Aa][Ii][Ll]%" ), email );
saveStr.replace( QRegExp( "%[Nn][Aa][Mm][Ee]%" ), emailName );
saveStr.replace( QRegExp( "%[Ss][Ee][Rr][Vv][Ee][Rr]%" ), emailHost );
KUrl retUrl( url );
retUrl.setPath( saveStr );
return retUrl;
}
static QString generateKey(const KUrl& url)
{
QString key;
if (url.isValid()) {
key = url.protocol();
key += QLatin1Char(':');
if (url.hasHost()) {
key += url.host();
key += QLatin1Char(':');
}
if (url.hasPath()) {
key += url.path();
}
}
return key;
}
void FileProtocol::stat( const KUrl & url )
{
if (!url.isLocalFile()) {
KUrl redir(url);
redir.setProtocol(config()->readEntry("DefaultRemoteProtocol", "smb"));
redirection(redir);
kDebug(7101) << "redirecting to " << redir.url();
finished();
return;
}
/* directories may not have a slash at the end if
* we want to stat() them; it requires that we
* change into it .. which may not be allowed
* stat("/is/unaccessible") -> rwx------
* stat("/is/unaccessible/") -> EPERM H.Z.
* This is the reason for the -1
*/
const QString path(url.path(KUrl::RemoveTrailingSlash));
const QByteArray _path( QFile::encodeName(path));
const QString sDetails = metaData(QLatin1String("details"));
const int details = sDetails.isEmpty() ? 2 : sDetails.toInt();
UDSEntry entry;
if ( !createUDSEntry( url.fileName(), _path, entry, details, true /*with acls*/ ) )
{
error(KIO::ERR_DOES_NOT_EXIST, path);
return;
}
#if 0
///////// debug code
MetaData::iterator it1 = mOutgoingMetaData.begin();
for ( ; it1 != mOutgoingMetaData.end(); it1++ ) {
kDebug(7101) << it1.key() << " = " << it1.data();
}
/////////
#endif
statEntry( entry );
finished();
}
bool Document::getURL( const QString &types )
{
KUrl url = KFileDialog::getSaveUrl( KUrl(), types, KTechlab::self(), i18n("Save Location"));
if ( url.isEmpty() ) return false;
if ( QFile::exists( url.path() ) )
{
int query = KMessageBox::warningYesNo( KTechlab::self(),
i18n( "A file named \"%1\" already exists. Are you sure you want to overwrite it?" ).arg( url.fileName() ),
i18n( "Overwrite File?" ),
//i18n( "Overwrite" ),
KStandardGuiItem::cancel() );
if ( query == KMessageBox::No )
return false;
}
setURL(url);
return true;
}
QString BatchProcessImagesDialog::RenameTargetImageFile(QFileInfo* fi)
{
QString Temp;
int Enumerator = 0;
KUrl NewDestUrl;
do
{
++Enumerator;
Temp = Temp.setNum(Enumerator);
NewDestUrl = fi->filePath().left(fi->filePath().lastIndexOf('.', -1)) + '_' + Temp + '.'
+ fi->filePath().section('.', -1);
}
while (Enumerator < 100 &&
KIO::NetAccess::exists(NewDestUrl, KIO::NetAccess::SourceSide, kapp->activeWindow()) == true);
if (Enumerator == 100)
return QString();
return (NewDestUrl.path());
}
void QuantaProjectPart::slotInsertFolder()
{
KUrl url = KUrl();
url = KFileDialog::getExistingUrl(m_projectBase, Koncrete::Core::mainWindow(), i18n("Insert Folder in Project"));
if (!url.isEmpty())
{
if (!m_projectBase.isParentOf(url))
{
KUrlRequesterDialog urlRequesterDlg(m_projectBase.pathOrUrl(), Koncrete::Core::mainWindow());
urlRequesterDlg.setWindowTitle(i18n("%1: Copy to Project", url.pathOrUrl()));
urlRequesterDlg.urlRequester()->setMode(KFile::Directory | KFile::ExistingOnly);
urlRequesterDlg.exec();
KUrl destination = urlRequesterDlg.selectedUrl();
if (!destination.isEmpty())
{
destination.adjustPath(KUrl::AddTrailingSlash);
QuantaNetAccess::dircopy(url, destination, this, false);
}
} else
{
KUrl::List urls = ExtFileInfo::allFilesRelative(url, "*");
QStringList filenames;
KUrl u = KUrl::relativeUrl(m_projectBase, url);
QStringList sections = u.path(KUrl::AddTrailingSlash).split('/', QString::SkipEmptyParts);
QString section;
for (int i = 0 ; i < sections.count(); i++)
{
section += sections[i] + '/';
filenames += section;
}
KUrl::List::ConstIterator end = urls.constEnd();
for (KUrl::List::ConstIterator it = urls.begin(); it != end; ++it)
{
filenames += url.fileName() + '/' + (*it).path();
}
addFiles(filenames);
}
}
}