• Skip to content
  • Skip to link menu
  • KDE API Reference
  • kdelibs-4.14.38 API Reference
  • KDE Home
  • Contact Us
 

KIO

  • kio
  • kio
forwardingslavebase.cpp
Go to the documentation of this file.
1/* This file is part of the KDE project
2 Copyright (c) 2004 Kevin Ottens <ervin@ipsquad.net>
3
4 This library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Library General Public
6 License as published by the Free Software Foundation; either
7 version 2 of the License, or (at your option) any later version.
8
9 This library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Library General Public License for more details.
13
14 You should have received a copy of the GNU Library General Public License
15 along with this library; see the file COPYING.LIB. If not, write to
16 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
17 Boston, MA 02110-1301, USA.
18*/
19
20#include "forwardingslavebase.h"
21
22#include "deletejob.h"
23#include "job.h"
24
25#include <kdebug.h>
26#include <kmimetype.h>
27
28#include <QtGui/QApplication>
29#include <QtCore/QEventLoop>
30
31namespace KIO
32{
33
34class ForwardingSlaveBasePrivate
35{
36public:
37 ForwardingSlaveBasePrivate(QObject * eventLoopParent) :
38 eventLoop(eventLoopParent)
39 {}
40 ForwardingSlaveBase *q;
41
42 KUrl m_processedURL;
43 KUrl m_requestedURL;
44 QEventLoop eventLoop;
45
46 bool internalRewriteUrl(const KUrl &url, KUrl &newURL);
47
48 void connectJob(Job *job);
49 void connectSimpleJob(SimpleJob *job);
50 void connectListJob(ListJob *job);
51 void connectTransferJob(TransferJob *job);
52
53 void _k_slotResult(KJob *job);
54 void _k_slotWarning(KJob *job, const QString &msg);
55 void _k_slotInfoMessage(KJob *job, const QString &msg);
56 void _k_slotTotalSize(KJob *job, qulonglong size);
57 void _k_slotProcessedSize(KJob *job, qulonglong size);
58 void _k_slotSpeed(KJob *job, unsigned long bytesPerSecond);
59
60 // KIO::SimpleJob subclasses
61 void _k_slotRedirection(KIO::Job *job, const KUrl &url);
62
63 // KIO::ListJob
64 void _k_slotEntries(KIO::Job *job, const KIO::UDSEntryList &entries);
65
66 // KIO::TransferJob
67 void _k_slotData(KIO::Job *job, const QByteArray &data);
68 void _k_slotDataReq(KIO::Job *job, QByteArray &data);
69 void _k_slotMimetype (KIO::Job *job, const QString &type);
70 void _k_slotCanResume (KIO::Job *job, KIO::filesize_t offset);
71};
72
73ForwardingSlaveBase::ForwardingSlaveBase(const QByteArray &protocol,
74 const QByteArray &poolSocket,
75 const QByteArray &appSocket)
76 : QObject(), SlaveBase(protocol, poolSocket, appSocket),
77 d( new ForwardingSlaveBasePrivate(this) )
78{
79 d->q = this;
80}
81
82ForwardingSlaveBase::~ForwardingSlaveBase()
83{
84 delete d;
85}
86
87bool ForwardingSlaveBasePrivate::internalRewriteUrl(const KUrl &url, KUrl &newURL)
88{
89 bool result = true;
90
91 if ( url.protocol() == q->mProtocol )
92 {
93 result = q->rewriteUrl(url, newURL);
94 }
95 else
96 {
97 newURL = url;
98 }
99
100 m_processedURL = newURL;
101 m_requestedURL = url;
102 return result;
103}
104
105void ForwardingSlaveBase::prepareUDSEntry(KIO::UDSEntry &entry,
106 bool listing) const
107{
108 //kDebug() << "listing==" << listing;
109
110 const QString name = entry.stringValue( KIO::UDSEntry::UDS_NAME );
111 QString mimetype = entry.stringValue( KIO::UDSEntry::UDS_MIME_TYPE );
112 KUrl url;
113 const QString urlStr = entry.stringValue( KIO::UDSEntry::UDS_URL );
114 const bool url_found = !urlStr.isEmpty();
115 if ( url_found )
116 {
117 url = urlStr;
118 KUrl new_url = d->m_requestedURL;
119 if (listing)
120 new_url.addPath(url.fileName());
121 // ## Didn't find a way to use an iterator instead of re-doing a key lookup
122 entry.insert( KIO::UDSEntry::UDS_URL, new_url.url() );
123 kDebug() << "URL =" << url;
124 kDebug() << "New URL =" << new_url;
125 }
126
127 if (mimetype.isEmpty())
128 {
129 KUrl new_url = d->m_processedURL;
130 if (url_found && listing)
131 {
132 new_url.addPath( url.fileName() );
133 }
134 else if (listing)
135 {
136 new_url.addPath( name );
137 }
138
139 mimetype = KMimeType::findByUrl(new_url)->name();
140
141 entry.insert( KIO::UDSEntry::UDS_MIME_TYPE, mimetype );
142
143 kDebug() << "New Mimetype = " << mimetype;
144 }
145
146 if ( d->m_processedURL.isLocalFile() )
147 {
148 KUrl new_url = d->m_processedURL;
149 if (listing)
150 {
151 new_url.addPath( name );
152 }
153
154 entry.insert( KIO::UDSEntry::UDS_LOCAL_PATH, new_url.toLocalFile() );
155 }
156}
157
158KUrl ForwardingSlaveBase::processedUrl() const
159{
160 return d->m_processedURL;
161}
162
163KUrl ForwardingSlaveBase::requestedUrl() const
164{
165 return d->m_requestedURL;
166}
167
168void ForwardingSlaveBase::get(const KUrl &url)
169{
170 kDebug() << url;
171
172 KUrl new_url;
173 if ( d->internalRewriteUrl(url, new_url) )
174 {
175 KIO::TransferJob *job = KIO::get(new_url, NoReload, HideProgressInfo);
176 d->connectTransferJob(job);
177
178 d->eventLoop.exec();
179 }
180 else
181 {
182 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
183 }
184}
185
186void ForwardingSlaveBase::put(const KUrl &url, int permissions,
187 JobFlags flags)
188{
189 kDebug() << url;
190
191 KUrl new_url;
192 if ( d->internalRewriteUrl(url, new_url) )
193 {
194 KIO::TransferJob *job = KIO::put(new_url, permissions,
195 flags | HideProgressInfo);
196 d->connectTransferJob(job);
197
198 d->eventLoop.exec();
199 }
200 else
201 {
202 error( KIO::ERR_MALFORMED_URL, url.prettyUrl() );
203 }
204}
205
206void ForwardingSlaveBase::stat(const KUrl &url)
207{
208 kDebug() << url;
209
210 KUrl new_url;
211 if ( d->internalRewriteUrl(url, new_url) )
212 {
213 KIO::SimpleJob *job = KIO::stat(new_url, KIO::HideProgressInfo);
214 d->connectSimpleJob(job);
215
216 d->eventLoop.exec();
217 }
218 else
219 {
220 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
221 }
222}
223
224void ForwardingSlaveBase::mimetype(const KUrl &url)
225{
226 kDebug() << url;
227
228 KUrl new_url;
229 if ( d->internalRewriteUrl(url, new_url) )
230 {
231 KIO::TransferJob *job = KIO::mimetype(new_url, KIO::HideProgressInfo);
232 d->connectTransferJob(job);
233
234 d->eventLoop.exec();
235 }
236 else
237 {
238 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
239 }
240}
241
242void ForwardingSlaveBase::listDir(const KUrl &url)
243{
244 kDebug() << url;
245
246 KUrl new_url;
247 if ( d->internalRewriteUrl(url, new_url) )
248 {
249 KIO::ListJob *job = KIO::listDir(new_url, KIO::HideProgressInfo);
250 d->connectListJob(job);
251
252 d->eventLoop.exec();
253 }
254 else
255 {
256 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
257 }
258}
259
260void ForwardingSlaveBase::mkdir(const KUrl &url, int permissions)
261{
262 kDebug() << url;
263
264 KUrl new_url;
265 if ( d->internalRewriteUrl(url, new_url) )
266 {
267 KIO::SimpleJob *job = KIO::mkdir(new_url, permissions);
268 d->connectSimpleJob(job);
269
270 d->eventLoop.exec();
271 }
272 else
273 {
274 error( KIO::ERR_MALFORMED_URL, url.prettyUrl() );
275 }
276}
277
278void ForwardingSlaveBase::rename(const KUrl &src, const KUrl &dest,
279 JobFlags flags)
280{
281 kDebug() << src << "," << dest;
282
283 KUrl new_src, new_dest;
284 if( !d->internalRewriteUrl(src, new_src) )
285 {
286 error(KIO::ERR_DOES_NOT_EXIST, src.prettyUrl());
287 }
288 else if ( d->internalRewriteUrl(dest, new_dest) )
289 {
290 KIO::Job *job = KIO::rename(new_src, new_dest, flags);
291 d->connectJob(job);
292
293 d->eventLoop.exec();
294 }
295 else
296 {
297 error( KIO::ERR_MALFORMED_URL, dest.prettyUrl() );
298 }
299}
300
301void ForwardingSlaveBase::symlink(const QString &target, const KUrl &dest,
302 JobFlags flags)
303{
304 kDebug() << target << ", " << dest;
305
306 KUrl new_dest;
307 if ( d->internalRewriteUrl(dest, new_dest) )
308 {
309 KIO::SimpleJob *job = KIO::symlink(target, new_dest, flags & HideProgressInfo);
310 d->connectSimpleJob(job);
311
312 d->eventLoop.exec();
313 }
314 else
315 {
316 error( KIO::ERR_MALFORMED_URL, dest.prettyUrl() );
317 }
318}
319
320void ForwardingSlaveBase::chmod(const KUrl &url, int permissions)
321{
322 kDebug() << url;
323
324 KUrl new_url;
325 if ( d->internalRewriteUrl(url, new_url) )
326 {
327 KIO::SimpleJob *job = KIO::chmod(new_url, permissions);
328 d->connectSimpleJob(job);
329
330 d->eventLoop.exec();
331 }
332 else
333 {
334 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
335 }
336}
337
338void ForwardingSlaveBase::setModificationTime(const KUrl& url, const QDateTime& mtime)
339{
340 kDebug() << url;
341
342 KUrl new_url;
343 if ( d->internalRewriteUrl(url, new_url) )
344 {
345 KIO::SimpleJob *job = KIO::setModificationTime(new_url, mtime);
346 d->connectSimpleJob(job);
347
348 d->eventLoop.exec();
349 }
350 else
351 {
352 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
353 }
354}
355
356void ForwardingSlaveBase::copy(const KUrl &src, const KUrl &dest,
357 int permissions, JobFlags flags)
358{
359 kDebug() << src << "," << dest;
360
361 KUrl new_src, new_dest;
362 if ( !d->internalRewriteUrl(src, new_src) )
363 {
364 error(KIO::ERR_DOES_NOT_EXIST, src.prettyUrl());
365 }
366 else if( d->internalRewriteUrl(dest, new_dest) )
367 {
368 // Are you sure you want to display here a ProgressInfo ???
369 KIO::Job *job = KIO::file_copy(new_src, new_dest, permissions,
370 (flags & (~Overwrite) & (~HideProgressInfo)) );
371 d->connectJob(job);
372
373 d->eventLoop.exec();
374 }
375 else
376 {
377 error( KIO::ERR_MALFORMED_URL, dest.prettyUrl() );
378 }
379}
380
381void ForwardingSlaveBase::del(const KUrl &url, bool isfile)
382{
383 kDebug() << url;
384
385 KUrl new_url;
386 if ( d->internalRewriteUrl(url, new_url) )
387 {
388 if (isfile)
389 {
390 KIO::DeleteJob *job = KIO::del(new_url, HideProgressInfo);
391 d->connectJob(job);
392 }
393 else
394 {
395 KIO::SimpleJob *job = KIO::rmdir(new_url);
396 d->connectSimpleJob(job);
397 }
398
399 d->eventLoop.exec();
400 }
401 else
402 {
403 error(KIO::ERR_DOES_NOT_EXIST, url.prettyUrl());
404 }
405}
406
407
409
410void ForwardingSlaveBasePrivate::connectJob(KIO::Job *job)
411{
412 // We will forward the warning message, no need to let the job
413 // display it itself
414 job->setUiDelegate( 0 );
415
416 // Forward metadata (e.g. modification time for put())
417 job->setMetaData( q->allMetaData() );
418#if 0 // debug code
419 kDebug() << "transferring metadata:";
420 const MetaData md = allMetaData();
421 for ( MetaData::const_iterator it = md.begin(); it != md.end(); ++it )
422 kDebug() << it.key() << " = " << it.data();
423#endif
424
425 q->connect( job, SIGNAL(result(KJob*)),
426 SLOT(_k_slotResult(KJob*)) );
427 q->connect( job, SIGNAL(warning(KJob*,QString,QString)),
428 SLOT(_k_slotWarning(KJob*,QString)) );
429 q->connect( job, SIGNAL(infoMessage(KJob*,QString,QString)),
430 SLOT(_k_slotInfoMessage(KJob*,QString)) );
431 q->connect( job, SIGNAL(totalSize(KJob*,qulonglong)),
432 SLOT(_k_slotTotalSize(KJob*,qulonglong)) );
433 q->connect( job, SIGNAL(processedSize(KJob*,qulonglong)),
434 SLOT(_k_slotProcessedSize(KJob*,qulonglong)) );
435 q->connect( job, SIGNAL(speed(KJob*,ulong)),
436 SLOT(_k_slotSpeed(KJob*,ulong)) );
437}
438
439void ForwardingSlaveBasePrivate::connectSimpleJob(KIO::SimpleJob *job)
440{
441 connectJob(job);
442 q->connect( job, SIGNAL(redirection(KIO::Job*,KUrl)),
443 SLOT(_k_slotRedirection(KIO::Job*,KUrl)) );
444}
445
446void ForwardingSlaveBasePrivate::connectListJob(KIO::ListJob *job)
447{
448 connectSimpleJob(job);
449 q->connect( job, SIGNAL(entries(KIO::Job*,KIO::UDSEntryList)),
450 SLOT(_k_slotEntries(KIO::Job*,KIO::UDSEntryList)) );
451}
452
453void ForwardingSlaveBasePrivate::connectTransferJob(KIO::TransferJob *job)
454{
455 connectSimpleJob(job);
456 q->connect( job, SIGNAL(data(KIO::Job*,QByteArray)),
457 SLOT(_k_slotData(KIO::Job*,QByteArray)) );
458 q->connect( job, SIGNAL(dataReq(KIO::Job*,QByteArray&)),
459 SLOT(_k_slotDataReq(KIO::Job*,QByteArray&)) );
460 q->connect( job, SIGNAL(mimetype(KIO::Job*,QString)),
461 SLOT(_k_slotMimetype(KIO::Job*,QString)) );
462 q->connect( job, SIGNAL(canResume(KIO::Job*,KIO::filesize_t)),
463 SLOT(_k_slotCanResume(KIO::Job*,KIO::filesize_t)) );
464}
465
467
468void ForwardingSlaveBasePrivate::_k_slotResult(KJob *job)
469{
470 if ( job->error() != 0)
471 {
472 q->error( job->error(), job->errorText() );
473 }
474 else
475 {
476 KIO::StatJob *stat_job = qobject_cast<KIO::StatJob *>(job);
477 if ( stat_job!=0L )
478 {
479 KIO::UDSEntry entry = stat_job->statResult();
480 q->prepareUDSEntry(entry);
481 q->statEntry( entry );
482 }
483 q->finished();
484 }
485
486 eventLoop.exit();
487}
488
489void ForwardingSlaveBasePrivate::_k_slotWarning(KJob* /*job*/, const QString &msg)
490{
491 q->warning(msg);
492}
493
494void ForwardingSlaveBasePrivate::_k_slotInfoMessage(KJob* /*job*/, const QString &msg)
495{
496 q->infoMessage(msg);
497}
498
499void ForwardingSlaveBasePrivate::_k_slotTotalSize(KJob* /*job*/, qulonglong size)
500{
501 q->totalSize(size);
502}
503
504void ForwardingSlaveBasePrivate::_k_slotProcessedSize(KJob* /*job*/, qulonglong size)
505{
506 q->processedSize(size);
507}
508
509void ForwardingSlaveBasePrivate::_k_slotSpeed(KJob* /*job*/, unsigned long bytesPerSecond)
510{
511 q->speed(bytesPerSecond);
512}
513
514void ForwardingSlaveBasePrivate::_k_slotRedirection(KIO::Job *job, const KUrl &url)
515{
516 q->redirection(url);
517
518 // We've been redirected stop everything.
519 job->kill( KJob::Quietly );
520 q->finished();
521
522 eventLoop.exit();
523}
524
525void ForwardingSlaveBasePrivate::_k_slotEntries(KIO::Job* /*job*/,
526 const KIO::UDSEntryList &entries)
527{
528 KIO::UDSEntryList final_entries = entries;
529
530 KIO::UDSEntryList::iterator it = final_entries.begin();
531 const KIO::UDSEntryList::iterator end = final_entries.end();
532
533 for(; it!=end; ++it)
534 {
535 q->prepareUDSEntry(*it, true);
536 }
537
538 q->listEntries( final_entries );
539}
540
541void ForwardingSlaveBasePrivate::_k_slotData(KIO::Job* /*job*/, const QByteArray &_data)
542{
543 q->data(_data);
544}
545
546void ForwardingSlaveBasePrivate::_k_slotDataReq(KIO::Job* /*job*/, QByteArray &data)
547{
548 q->dataReq();
549 q->readData(data);
550}
551
552void ForwardingSlaveBasePrivate::_k_slotMimetype (KIO::Job* /*job*/, const QString &type)
553{
554 q->mimeType(type);
555}
556
557void ForwardingSlaveBasePrivate::_k_slotCanResume (KIO::Job* /*job*/, KIO::filesize_t offset)
558{
559 q->canResume(offset);
560}
561
562}
563
564#include "forwardingslavebase.moc"
565
KIO::DeleteJob
A more complex Job to delete files and directories.
Definition: deletejob.h:43
KIO::ForwardingSlaveBase::requestedUrl
KUrl requestedUrl() const
Return the URL asked to the ioslave Only access it inside prepareUDSEntry()
Definition: forwardingslavebase.cpp:163
KIO::ForwardingSlaveBase::~ForwardingSlaveBase
virtual ~ForwardingSlaveBase()
Definition: forwardingslavebase.cpp:82
KIO::ForwardingSlaveBase::chmod
virtual void chmod(const KUrl &url, int permissions)
Change permissions on url The slave emits ERR_DOES_NOT_EXIST or ERR_CANNOT_CHMOD.
Definition: forwardingslavebase.cpp:320
KIO::ForwardingSlaveBase::rename
virtual void rename(const KUrl &src, const KUrl &dest, JobFlags flags)
Rename oldname into newname.
Definition: forwardingslavebase.cpp:278
KIO::ForwardingSlaveBase::mkdir
virtual void mkdir(const KUrl &url, int permissions)
Create a directory.
Definition: forwardingslavebase.cpp:260
KIO::ForwardingSlaveBase::del
virtual void del(const KUrl &url, bool isfile)
Delete a file or directory.
Definition: forwardingslavebase.cpp:381
KIO::ForwardingSlaveBase::copy
virtual void copy(const KUrl &src, const KUrl &dest, int permissions, JobFlags flags)
Copy src into dest.
Definition: forwardingslavebase.cpp:356
KIO::ForwardingSlaveBase::stat
virtual void stat(const KUrl &url)
Finds all details for one file or directory.
Definition: forwardingslavebase.cpp:206
KIO::ForwardingSlaveBase::listDir
virtual void listDir(const KUrl &url)
Lists the contents of url.
Definition: forwardingslavebase.cpp:242
KIO::ForwardingSlaveBase::processedUrl
KUrl processedUrl() const
Return the URL being processed by the ioslave Only access it inside prepareUDSEntry()
Definition: forwardingslavebase.cpp:158
KIO::ForwardingSlaveBase::put
virtual void put(const KUrl &url, int permissions, JobFlags flags)
put, i.e.
Definition: forwardingslavebase.cpp:186
KIO::ForwardingSlaveBase::setModificationTime
virtual void setModificationTime(const KUrl &url, const QDateTime &mtime)
Sets the modification time for @url For instance this is what CopyJob uses to set mtime on dirs at th...
Definition: forwardingslavebase.cpp:338
KIO::ForwardingSlaveBase::symlink
virtual void symlink(const QString &target, const KUrl &dest, JobFlags flags)
Creates a symbolic link named dest, pointing to target, which may be a relative or an absolute path.
Definition: forwardingslavebase.cpp:301
KIO::ForwardingSlaveBase::prepareUDSEntry
virtual void prepareUDSEntry(KIO::UDSEntry &entry, bool listing=false) const
Allow to modify a UDSEntry before it's sent to the ioslave endpoint.
Definition: forwardingslavebase.cpp:105
KIO::ForwardingSlaveBase::ForwardingSlaveBase
ForwardingSlaveBase(const QByteArray &protocol, const QByteArray &poolSocket, const QByteArray &appSocket)
Definition: forwardingslavebase.cpp:73
KIO::ForwardingSlaveBase::mimetype
virtual void mimetype(const KUrl &url)
Finds mimetype for one file or directory.
Definition: forwardingslavebase.cpp:224
KIO::ForwardingSlaveBase::get
virtual void get(const KUrl &url)
get, aka read.
Definition: forwardingslavebase.cpp:168
KIO::Job
The base class for all jobs.
Definition: jobclasses.h:94
KIO::Job::setMetaData
void setMetaData(const KIO::MetaData &metaData)
Set meta data to be sent to the slave, replacing existing meta data.
Definition: job.cpp:258
KIO::ListJob
A ListJob is allows you to get the get the content of a directory.
Definition: jobclasses.h:936
KIO::MetaData
MetaData is a simple map of key/value strings.
Definition: global.h:397
KIO::SimpleJob
A simple job (one url and one command).
Definition: jobclasses.h:322
KIO::SlaveBase
There are two classes that specifies the protocol between application (job) and kioslave.
Definition: slavebase.h:51
KIO::SlaveBase::error
void error(int _errid, const QString &_text)
Call to signal an error.
Definition: slavebase.cpp:419
KIO::StatJob
A KIO job that retrieves information about a file or directory.
Definition: jobclasses.h:440
KIO::StatJob::statResult
const UDSEntry & statResult() const
Result of the stat operation.
Definition: job.cpp:839
KIO::TransferJob
The transfer job pumps data into and/or out of a Slave.
Definition: jobclasses.h:555
KIO::UDSEntry
Universal Directory Service.
Definition: udsentry.h:59
KIO::UDSEntry::stringValue
QString stringValue(uint field) const
Definition: udsentry.cpp:73
KIO::UDSEntry::UDS_URL
@ UDS_URL
An alternative URL (If different from the caption).
Definition: udsentry.h:190
KIO::UDSEntry::UDS_MIME_TYPE
@ UDS_MIME_TYPE
A mime type; the slave should set it if it's known.
Definition: udsentry.h:192
KIO::UDSEntry::UDS_LOCAL_PATH
@ UDS_LOCAL_PATH
A local file path if the ioslave display files sitting on the local filesystem (but in another hierar...
Definition: udsentry.h:166
KIO::UDSEntry::UDS_NAME
@ UDS_NAME
Filename - as displayed in directory listings etc.
Definition: udsentry.h:163
KIO::UDSEntry::insert
void insert(uint field, const QString &value)
insert field with numeric value
Definition: udsentry.cpp:94
KJob
KJob::Quietly
Quietly
KJob::error
int error() const
KJob::kill
bool kill(KillVerbosity verbosity=Quietly)
KJob::errorText
QString errorText() const
KJob::setUiDelegate
void setUiDelegate(KJobUiDelegate *delegate)
KMimeType::findByUrl
static Ptr findByUrl(const KUrl &url, mode_t mode=0, bool is_local_file=false, bool fast_mode=false, int *accuracy=0)
KUrl
KUrl::prettyUrl
QString prettyUrl(AdjustPathOption trailing=LeaveTrailingSlash) const
KUrl::url
QString url(AdjustPathOption trailing=LeaveTrailingSlash) const
KUrl::fileName
QString fileName(const DirectoryOptions &options=IgnoreTrailingSlash) const
KUrl::protocol
QString protocol() const
KUrl::toLocalFile
QString toLocalFile(AdjustPathOption trailing=LeaveTrailingSlash) const
KUrl::addPath
void addPath(const QString &txt)
QList< UDSEntry >
QObject
deletejob.h
forwardingslavebase.h
kDebug
#define kDebug
job.h
kdebug.h
kmimetype.h
KIO
A namespace for KIO globals.
Definition: kbookmarkmenu.h:55
KIO::del
DeleteJob * del(const KUrl &src, JobFlags flags=DefaultFlags)
Delete a file or directory.
Definition: deletejob.cpp:492
KIO::chmod
ChmodJob * chmod(const KFileItemList &lstItems, int permissions, int mask, const QString &newOwner, const QString &newGroup, bool recursive, JobFlags flags=DefaultFlags)
Creates a job that changes permissions/ownership on several files or directories, optionally recursiv...
Definition: chmodjob.cpp:268
KIO::setModificationTime
SimpleJob * setModificationTime(const KUrl &url, const QDateTime &mtime)
Changes the modification time on a file or directory.
Definition: job.cpp:724
KIO::rmdir
SimpleJob * rmdir(const KUrl &url)
Removes a single directory.
Definition: job.cpp:704
KIO::stat
StatJob * stat(const KUrl &url, JobFlags flags=DefaultFlags)
Find all details for one file or directory.
Definition: job.cpp:924
KIO::put
TransferJob * put(const KUrl &url, int permissions, JobFlags flags=DefaultFlags)
Put (a.k.a.
Definition: job.cpp:1700
KIO::listDir
ListJob * listDir(const KUrl &url, JobFlags flags=DefaultFlags, bool includeHidden=true)
List the contents of url, which is assumed to be a directory.
Definition: job.cpp:2735
KIO::file_copy
FileCopyJob * file_copy(const KUrl &src, const KUrl &dest, int permissions=-1, JobFlags flags=DefaultFlags)
Copy a single file.
Definition: job.cpp:2473
KIO::get
TransferJob * get(const KUrl &url, LoadType reload=NoReload, JobFlags flags=DefaultFlags)
Get (a.k.a.
Definition: job.cpp:1369
KIO::mkdir
SimpleJob * mkdir(const KUrl &url, int permissions=-1)
Creates a single directory.
Definition: job.cpp:697
KIO::NoReload
@ NoReload
Definition: job.h:29
KIO::mimetype
MimetypeJob * mimetype(const KUrl &url, JobFlags flags=DefaultFlags)
Find mimetype for one file or directory.
Definition: job.cpp:1856
KIO::rename
SimpleJob * rename(const KUrl &src, const KUrl &dest, JobFlags flags=DefaultFlags)
Rename a file or directory.
Definition: job.cpp:731
KIO::HideProgressInfo
@ HideProgressInfo
Hide progress information dialog, i.e.
Definition: jobclasses.h:51
KIO::Overwrite
@ Overwrite
When set, automatically overwrite the destination if it exists already.
Definition: jobclasses.h:67
KIO::filesize_t
qulonglong filesize_t
64-bit file size
Definition: global.h:57
KIO::ERR_DOES_NOT_EXIST
@ ERR_DOES_NOT_EXIST
Definition: global.h:205
KIO::ERR_MALFORMED_URL
@ ERR_MALFORMED_URL
Definition: global.h:199
KIO::symlink
SimpleJob * symlink(const QString &target, const KUrl &dest, JobFlags flags=DefaultFlags)
Create or move a symlink.
Definition: job.cpp:738
name
const char * name(StandardAction id)
end
const KShortcut & end()
This file is part of the KDE documentation.
Documentation copyright © 1996-2023 The KDE developers.
Generated on Mon Feb 20 2023 00:00:00 by doxygen 1.9.6 written by Dimitri van Heesch, © 1997-2006

KDE's Doxygen guidelines are available online.

KIO

Skip menu "KIO"
  • Main Page
  • Namespace List
  • Namespace Members
  • Alphabetical List
  • Class List
  • Class Hierarchy
  • Class Members
  • File List
  • File Members
  • Related Pages

kdelibs-4.14.38 API Reference

Skip menu "kdelibs-4.14.38 API Reference"
  • DNSSD
  • Interfaces
  •   KHexEdit
  •   KMediaPlayer
  •   KSpeech
  •   KTextEditor
  • kconf_update
  • KDE3Support
  •   KUnitTest
  • KDECore
  • KDED
  • KDEsu
  • KDEUI
  • KDEWebKit
  • KDocTools
  • KFile
  • KHTML
  • KImgIO
  • KInit
  • kio
  • KIOSlave
  • KJS
  •   KJS-API
  •   WTF
  • kjsembed
  • KNewStuff
  • KParts
  • KPty
  • Kross
  • KUnitConversion
  • KUtils
  • Nepomuk
  • Plasma
  • Solid
  • Sonnet
  • ThreadWeaver
Report problems with this website to our bug tracking system.
Contact the specific authors with questions and comments about the page contents.

KDE® and the K Desktop Environment® logo are registered trademarks of KDE e.V. | Legal