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

KIO

  • sources
  • kde-4.14
  • kdelibs
  • kio
  • kio
slaveinterface.cpp
Go to the documentation of this file.
1 /* This file is part of the KDE libraries
2  Copyright (C) 2000 David Faure <faure@kde.org>
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 version 2 as published by the Free Software Foundation.
7 
8  This library is distributed in the hope that it will be useful,
9  but WITHOUT ANY WARRANTY; without even the implied warranty of
10  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
11  Library General Public License for more details.
12 
13  You should have received a copy of the GNU Library General Public License
14  along with this library; see the file COPYING.LIB. If not, write to
15  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
16  Boston, MA 02110-1301, USA.
17 */
18 
19 #include "slaveinterface.h"
20 #include "slaveinterface_p.h"
21 #include "usernotificationhandler_p.h"
22 
23 #include "slavebase.h"
24 #include "connection.h"
25 #include "hostinfo_p.h"
26 
27 #include <errno.h>
28 #include <stdlib.h>
29 #include <sys/time.h>
30 #include <unistd.h>
31 #include <signal.h>
32 #include <time.h>
33 
34 #include <kdebug.h>
35 #include <klocale.h>
36 
37 #include <QtDBus/QtDBus>
38 #include <QtCore/QPointer>
39 #include <QtNetwork/QSslCertificate>
40 #include <QtNetwork/QSslError>
41 
42 using namespace KIO;
43 
44 
45 Q_GLOBAL_STATIC(UserNotificationHandler, globalUserNotificationHandler)
46 
47 
48 SlaveInterface::SlaveInterface(SlaveInterfacePrivate &dd, QObject *parent)
49  : QObject(parent), d_ptr(&dd)
50 {
51  connect(&d_ptr->speed_timer, SIGNAL(timeout()), SLOT(calcSpeed()));
52 }
53 
54 SlaveInterface::~SlaveInterface()
55 {
56  // Note: no kDebug() here (scheduler is deleted very late)
57 
58  delete d_ptr;
59 }
60 
61 void SlaveInterface::setConnection( Connection* connection )
62 {
63  Q_D(SlaveInterface);
64  d->connection = connection;
65 }
66 
67 Connection *SlaveInterface::connection() const
68 {
69  const Q_D(SlaveInterface);
70  return d->connection;
71 }
72 
73 static KIO::filesize_t readFilesize_t(QDataStream &stream)
74 {
75  KIO::filesize_t result;
76  stream >> result;
77  return result;
78 }
79 
80 bool SlaveInterface::dispatch()
81 {
82  Q_D(SlaveInterface);
83  Q_ASSERT( d->connection );
84 
85  int cmd;
86  QByteArray data;
87 
88  int ret = d->connection->read( &cmd, data );
89  if (ret == -1)
90  return false;
91 
92  return dispatch( cmd, data );
93 }
94 
95 void SlaveInterface::calcSpeed()
96 {
97  Q_D(SlaveInterface);
98  if (d->slave_calcs_speed) {
99  d->speed_timer.stop();
100  return;
101  }
102 
103  struct timeval tv;
104  gettimeofday(&tv, 0);
105 
106  long diff = ((tv.tv_sec - d->start_time.tv_sec) * 1000000 +
107  tv.tv_usec - d->start_time.tv_usec) / 1000;
108  if (diff - d->last_time >= 900) {
109  d->last_time = diff;
110  if (d->nums == max_nums) {
111  // let's hope gcc can optimize that well enough
112  // otherwise I'd try memcpy :)
113  for (unsigned int i = 1; i < max_nums; ++i) {
114  d->times[i-1] = d->times[i];
115  d->sizes[i-1] = d->sizes[i];
116  }
117  d->nums--;
118  }
119  d->times[d->nums] = diff;
120  d->sizes[d->nums++] = d->filesize - d->offset;
121 
122  KIO::filesize_t lspeed = 1000 * (d->sizes[d->nums-1] - d->sizes[0]) / (d->times[d->nums-1] - d->times[0]);
123 
124 // kDebug() << (long)d->filesize << diff
125 // << long(d->sizes[d->nums-1] - d->sizes[0])
126 // << d->times[d->nums-1] - d->times[0]
127 // << long(lspeed) << double(d->filesize) / diff
128 // << convertSize(lspeed)
129 // << convertSize(long(double(d->filesize) / diff) * 1000);
130 
131  if (!lspeed) {
132  d->nums = 1;
133  d->times[0] = diff;
134  d->sizes[0] = d->filesize - d->offset;
135  }
136  emit speed(lspeed);
137  }
138 }
139 
140 #ifndef KDE_USE_FINAL // already defined in slavebase.cpp
141 /*
142  * Map pid_t to a signed integer type that makes sense for QByteArray;
143  * only the most common sizes 16 bit and 32 bit are special-cased.
144  */
145 template<int T> struct PIDType { typedef pid_t PID_t; } ;
146 template<> struct PIDType<2> { typedef qint16 PID_t; } ;
147 template<> struct PIDType<4> { typedef qint32 PID_t; } ;
148 #endif
149 
150 bool SlaveInterface::dispatch(int _cmd, const QByteArray &rawdata)
151 {
152  Q_D(SlaveInterface);
153  //kDebug(7007) << "dispatch " << _cmd;
154 
155  QDataStream stream(rawdata);
156 
157  QString str1;
158  qint32 i;
159  qint8 b;
160  quint32 ul;
161 
162  switch(_cmd) {
163  case MSG_DATA:
164  emit data(rawdata);
165  break;
166  case MSG_DATA_REQ:
167  emit dataReq();
168  break;
169  case MSG_OPENED:
170  emit open();
171  break;
172  case MSG_FINISHED:
173  //kDebug(7007) << "Finished [this = " << this << "]";
174  d->offset = 0;
175  d->speed_timer.stop();
176  emit finished();
177  break;
178  case MSG_STAT_ENTRY: {
179  UDSEntry entry;
180  stream >> entry;
181  emit statEntry(entry);
182  break;
183  }
184  case MSG_LIST_ENTRIES: {
185  quint32 count;
186  stream >> count;
187 
188  UDSEntryList list;
189  UDSEntry entry;
190  for (uint i = 0; i < count; i++) {
191  stream >> entry;
192  list.append(entry);
193  }
194  emit listEntries(list);
195  break;
196  }
197  case MSG_RESUME: { // From the put job
198  d->offset = readFilesize_t(stream);
199  emit canResume(d->offset);
200  break;
201  }
202  case MSG_CANRESUME: // From the get job
203  d->filesize = d->offset;
204  emit canResume(0); // the arg doesn't matter
205  break;
206  case MSG_ERROR:
207  stream >> i >> str1;
208  kDebug(7007) << "error " << i << " " << str1;
209  emit error(i, str1);
210  break;
211  case MSG_SLAVE_STATUS: {
212  PIDType<sizeof(pid_t)>::PID_t stream_pid;
213  pid_t pid;
214  QByteArray protocol;
215  stream >> stream_pid >> protocol >> str1 >> b;
216  pid = stream_pid;
217  emit slaveStatus(pid, protocol, str1, (b != 0));
218  break;
219  }
220  case MSG_CONNECTED:
221  emit connected();
222  break;
223  case MSG_WRITTEN: {
224  KIO::filesize_t size = readFilesize_t(stream);
225  emit written(size);
226  break;
227  }
228  case INF_TOTAL_SIZE: {
229  KIO::filesize_t size = readFilesize_t(stream);
230  gettimeofday(&d->start_time, 0);
231  d->last_time = 0;
232  d->filesize = d->offset;
233  d->sizes[0] = d->filesize - d->offset;
234  d->times[0] = 0;
235  d->nums = 1;
236  d->speed_timer.start(1000);
237  d->slave_calcs_speed = false;
238  emit totalSize(size);
239  break;
240  }
241  case INF_PROCESSED_SIZE: {
242  KIO::filesize_t size = readFilesize_t(stream);
243  emit processedSize( size );
244  d->filesize = size;
245  break;
246  }
247  case INF_POSITION: {
248  KIO::filesize_t pos = readFilesize_t(stream);
249  emit position(pos);
250  break;
251  }
252  case INF_SPEED:
253  stream >> ul;
254  d->slave_calcs_speed = true;
255  d->speed_timer.stop();
256  emit speed( ul );
257  break;
258  case INF_GETTING_FILE:
259  break;
260  case INF_ERROR_PAGE:
261  emit errorPage();
262  break;
263  case INF_REDIRECTION: {
264  KUrl url;
265  stream >> url;
266  emit redirection( url );
267  break;
268  }
269  case INF_MIME_TYPE:
270  stream >> str1;
271  emit mimeType(str1);
272  if (!d->connection->suspended())
273  d->connection->sendnow(CMD_NONE, QByteArray());
274  break;
275  case INF_WARNING:
276  stream >> str1;
277  emit warning(str1);
278  break;
279  case INF_MESSAGEBOX: {
280  kDebug(7007) << "needs a msg box";
281  QString text, caption, buttonYes, buttonNo, dontAskAgainName;
282  int type;
283  stream >> type >> text >> caption >> buttonYes >> buttonNo;
284  if (stream.atEnd()) {
285  messageBox(type, text, caption, buttonYes, buttonNo);
286  } else {
287  stream >> dontAskAgainName;
288  messageBox(type, text, caption, buttonYes, buttonNo, dontAskAgainName);
289  }
290  break;
291  }
292  case INF_INFOMESSAGE: {
293  QString msg;
294  stream >> msg;
295  emit infoMessage(msg);
296  break;
297  }
298  case INF_META_DATA: {
299  MetaData m;
300  stream >> m;
301  if (m.contains(QLatin1String("ssl_in_use"))) {
302  const QLatin1String ssl_("ssl_");
303  const MetaData constM = m;
304  for (MetaData::ConstIterator it = constM.lowerBound(ssl_); it != constM.constEnd(); ++it) {
305  if (it.key().startsWith(ssl_)) {
306  d->sslMetaData.insert(it.key(), it.value());
307  } else {
308  // we're past the ssl_* entries; remember that QMap is ordered.
309  break;
310  }
311  }
312  }
313  emit metaData(m);
314  break;
315  }
316  case MSG_NET_REQUEST: {
317  QString host;
318  QString slaveid;
319  stream >> host >> slaveid;
320  requestNetwork(host, slaveid);
321  break;
322  }
323  case MSG_NET_DROP: {
324  QString host;
325  QString slaveid;
326  stream >> host >> slaveid;
327  dropNetwork(host, slaveid);
328  break;
329  }
330  case MSG_NEED_SUBURL_DATA: {
331  emit needSubUrlData();
332  break;
333  }
334  case MSG_HOST_INFO_REQ: {
335  QString hostName;
336  stream >> hostName;
337  HostInfo::lookupHost(hostName, this, SLOT(slotHostInfo(QHostInfo)));
338  break;
339  }
340  default:
341  kWarning(7007) << "Slave sends unknown command (" << _cmd << "), dropping slave";
342  return false;
343  }
344  return true;
345 }
346 
347 void SlaveInterface::setOffset( KIO::filesize_t o)
348 {
349  Q_D(SlaveInterface);
350  d->offset = o;
351 }
352 
353 KIO::filesize_t SlaveInterface::offset() const
354 {
355  const Q_D(SlaveInterface);
356  return d->offset;
357 }
358 
359 void SlaveInterface::requestNetwork(const QString &host, const QString &slaveid)
360 {
361  Q_D(SlaveInterface);
362  kDebug(7007) << "requestNetwork " << host << slaveid;
363  QByteArray packedArgs;
364  QDataStream stream( &packedArgs, QIODevice::WriteOnly );
365  stream << true;
366  d->connection->sendnow( INF_NETWORK_STATUS, packedArgs );
367 }
368 
369 void SlaveInterface::dropNetwork(const QString &host, const QString &slaveid)
370 {
371  kDebug(7007) << "dropNetwork " << host << slaveid;
372 }
373 
374 void SlaveInterface::sendResumeAnswer( bool resume )
375 {
376  Q_D(SlaveInterface);
377  kDebug(7007) << "ok for resuming:" << resume;
378  d->connection->sendnow( resume ? CMD_RESUMEANSWER : CMD_NONE, QByteArray() );
379 }
380 
381 void SlaveInterface::sendMessageBoxAnswer(int result)
382 {
383  Q_D(SlaveInterface);
384  if (!d->connection) {
385  return;
386  }
387 
388  if (d->connection->suspended()) {
389  d->connection->resume();
390  }
391  QByteArray packedArgs;
392  QDataStream stream( &packedArgs, QIODevice::WriteOnly );
393  stream << result;
394  d->connection->sendnow(CMD_MESSAGEBOXANSWER, packedArgs);
395  kDebug(7007) << "message box answer" << result;
396 }
397 
398 void SlaveInterface::messageBox( int type, const QString &text, const QString &_caption,
399  const QString &buttonYes, const QString &buttonNo )
400 {
401  messageBox( type, text, _caption, buttonYes, buttonNo, QString() );
402 }
403 
404 void SlaveInterface::messageBox( int type, const QString &text, const QString &caption,
405  const QString &buttonYes, const QString &buttonNo, const QString &dontAskAgainName )
406 {
407  Q_D(SlaveInterface);
408 
409  if (d->connection) {
410  d->connection->suspend();
411  }
412 
413  QHash<UserNotificationHandler::MessageBoxDataType, QVariant> data;
414  data.insert(UserNotificationHandler::MSG_TEXT, text);
415  data.insert(UserNotificationHandler::MSG_CAPTION, caption);
416  data.insert(UserNotificationHandler::MSG_YES_BUTTON_TEXT, buttonYes);
417  data.insert(UserNotificationHandler::MSG_NO_BUTTON_TEXT, buttonNo);
418  data.insert(UserNotificationHandler::MSG_DONT_ASK_AGAIN, dontAskAgainName);
419 
420  // SMELL: the braindead way to support button icons
421  // TODO: Fix this in KIO::SlaveBase.
422  if (buttonYes == i18n("&Details")) {
423  data.insert(UserNotificationHandler::MSG_YES_BUTTON_ICON, QLatin1String("help-about"));
424  } else if (buttonYes == i18n("&Forever")) {
425  data.insert(UserNotificationHandler::MSG_YES_BUTTON_ICON, QLatin1String("flag-green"));
426  }
427 
428  if (buttonNo == i18n("Co&ntinue")) {
429  data.insert(UserNotificationHandler::MSG_NO_BUTTON_ICON, QLatin1String("arrow-right"));
430  } else if (buttonNo == i18n("&Current Session only")) {
431  data.insert(UserNotificationHandler::MSG_NO_BUTTON_ICON, QLatin1String("chronometer"));
432  }
433 
434  if (type == KIO::SlaveBase::SSLMessageBox) {
435  data.insert(UserNotificationHandler::MSG_META_DATA, d->sslMetaData.toVariant());
436  }
437 
438  globalUserNotificationHandler()->requestMessageBox(this, type, data);
439 }
440 
441 void SlaveInterface::setWindow (QWidget* window)
442 {
443  Q_D(SlaveInterface);
444  d->parentWindow = window;
445 }
446 
447 QWidget* SlaveInterface::window() const
448 {
449  const Q_D(SlaveInterface);
450  return d->parentWindow;
451 }
452 
453 void SlaveInterfacePrivate::slotHostInfo(const QHostInfo& info)
454 {
455  QByteArray data;
456  QDataStream stream(&data, QIODevice::WriteOnly);
457  stream << info.hostName() << info.addresses() << info.error() << info.errorString();
458  connection->send(CMD_HOST_INFO, data);
459 }
460 
461 #include "slaveinterface.moc"
caption
QString caption()
i18n
QString i18n(const char *text)
KIO::UserNotificationHandler::MSG_NO_BUTTON_TEXT
Definition: usernotificationhandler_p.h:41
QWidget
KIO::SlaveInterface::setWindow
void setWindow(QWidget *window)
Sets the top level window used as a parent when displaying dialogs.
Definition: slaveinterface.cpp:441
KIO::filesize_t
qulonglong filesize_t
64-bit file size
Definition: global.h:57
QHash::insert
iterator insert(const Key &key, const T &value)
QHostInfo::errorString
QString errorString() const
KIO::INF_NETWORK_STATUS
Definition: slaveinterface.h:58
KIO::INF_INFOMESSAGE
Definition: slaveinterface.h:56
KIO::SlaveInterface::data
void data(const QByteArray &)
KIO::SlaveInterface::position
void position(KIO::filesize_t)
KIO::SlaveInterface::d_ptr
SlaveInterfacePrivate *const d_ptr
Definition: slaveinterface.h:202
KIO::INF_PROCESSED_SIZE
Definition: slaveinterface.h:48
kdebug.h
slaveinterface.h
KIO::INF_META_DATA
Definition: slaveinterface.h:57
QByteArray
KIO::UserNotificationHandler::MSG_YES_BUTTON_ICON
Definition: usernotificationhandler_p.h:42
KIO::UDSEntry
Universal Directory Service.
Definition: udsentry.h:58
connection.h
KIO::SlaveInterface::needSubUrlData
void needSubUrlData()
QDataStream
timeout
int timeout
KIO::SlaveInterface
There are two classes that specifies the protocol between application ( KIO::Job) and kioslave...
Definition: slaveinterface.h:98
KIO::UserNotificationHandler::MSG_TEXT
Definition: usernotificationhandler_p.h:38
usernotificationhandler_p.h
KIO::UserNotificationHandler::MSG_META_DATA
Definition: usernotificationhandler_p.h:45
KIO::SlaveInterface::open
void open()
KIO::SlaveInterfacePrivate::slotHostInfo
void slotHostInfo(const QHostInfo &info)
Definition: slaveinterface.cpp:453
KIO::SlaveInterface::totalSize
void totalSize(KIO::filesize_t)
KIO::SlaveInterface::errorPage
void errorPage()
KIO::SlaveInterface::~SlaveInterface
virtual ~SlaveInterface()
Definition: slaveinterface.cpp:54
KIO::MSG_CONNECTED
Definition: slaveinterface.h:71
KIO::HostInfo::lookupHost
void lookupHost(const QString &hostName, QObject *receiver, const char *member)
Definition: hostinfo.cpp:240
quint32
KIO::SlaveInterface::dataReq
void dataReq()
kDebug
static QDebug kDebug(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
klocale.h
KIO::MSG_DATA
Definition: slaveinterface.h:68
KIO::SlaveInterface::setConnection
void setConnection(Connection *connection)
Definition: slaveinterface.cpp:61
KIO::MetaData
MetaData is a simple map of key/value strings.
Definition: global.h:396
KIO::MSG_SLAVE_STATUS
Definition: slaveinterface.h:77
KUrl
KIO::UserNotificationHandler::MSG_YES_BUTTON_TEXT
Definition: usernotificationhandler_p.h:40
KIO::SlaveInterface::sendMessageBoxAnswer
void sendMessageBoxAnswer(int result)
Sends our answer for the INF_MESSAGEBOX request.
Definition: slaveinterface.cpp:381
KIO::MSG_FINISHED
Definition: slaveinterface.h:72
KIO::SlaveInterface::connection
Connection * connection() const
Definition: slaveinterface.cpp:67
KIO::UserNotificationHandler
Definition: usernotificationhandler_p.h:33
KIO::SlaveInterface::speed
void speed(unsigned long)
KIO::MSG_RESUME
Definition: slaveinterface.h:76
KIO::SlaveInterfacePrivate
Definition: slaveinterface_p.h:32
KIO::MSG_LIST_ENTRIES
Definition: slaveinterface.h:74
KIO::SlaveInterface::finished
void finished()
KIO::SlaveInterface::redirection
void redirection(const KUrl &)
QList::append
void append(const T &value)
KIO::MSG_NET_DROP
Definition: slaveinterface.h:80
QHash
KIO::SlaveInterface::offset
KIO::filesize_t offset() const
Definition: slaveinterface.cpp:353
QObject
readFilesize_t
static KIO::filesize_t readFilesize_t(QDataStream &stream)
Definition: slaveinterface.cpp:73
QMap::constEnd
const_iterator constEnd() const
KIO::MSG_NEED_SUBURL_DATA
Definition: slaveinterface.h:81
KIO::UserNotificationHandler::MSG_DONT_ASK_AGAIN
Definition: usernotificationhandler_p.h:44
KIO::SlaveInterface::written
void written(KIO::filesize_t)
KIO::MSG_STAT_ENTRY
Definition: slaveinterface.h:73
KIO::MSG_NET_REQUEST
Definition: slaveinterface.h:79
QString
QList< UDSEntry >
QDataStream::atEnd
bool atEnd() const
KIO::SlaveInterface::sendResumeAnswer
void sendResumeAnswer(bool resume)
Definition: slaveinterface.cpp:374
KIO::SlaveInterface::connected
void connected()
QMap::lowerBound
iterator lowerBound(const Key &key)
KIO::SlaveBase::SSLMessageBox
Definition: slavebase.h:248
KIO::SlaveInterface::listEntries
void listEntries(const KIO::UDSEntryList &)
KIO::SlaveInterface::statEntry
void statEntry(const KIO::UDSEntry &)
KIO::INF_TOTAL_SIZE
Definition: slaveinterface.h:47
KIO::SlaveInterface::window
QWidget * window() const
Returns the top level window used as parent when displaying dialogs.
Definition: slaveinterface.cpp:447
KIO::CMD_RESUMEANSWER
Definition: global.h:176
KIO::INF_WARNING
Definition: slaveinterface.h:53
KIO::CMD_MESSAGEBOXANSWER
Definition: global.h:175
KIO::UserNotificationHandler::MSG_NO_BUTTON_ICON
Definition: usernotificationhandler_p.h:43
KIO::SlaveInterface::mimeType
void mimeType(const QString &)
KIO::UserNotificationHandler::MSG_CAPTION
Definition: usernotificationhandler_p.h:39
KIO::INF_POSITION
Definition: slaveinterface.h:60
KIO::INF_SPEED
Definition: slaveinterface.h:49
KIO::INF_MESSAGEBOX
Definition: slaveinterface.h:59
KIO::INF_REDIRECTION
Definition: slaveinterface.h:50
KIO::SlaveInterface::infoMessage
void infoMessage(const QString &)
QHostInfo::addresses
QList< QHostAddress > addresses() const
KIO::SlaveInterface::warning
void warning(const QString &)
KIO::MSG_DATA_REQ
Definition: slaveinterface.h:69
KIO::CMD_NONE
Definition: global.h:157
QLatin1String
KIO::SlaveInterface::calcSpeed
void calcSpeed()
Definition: slaveinterface.cpp:95
KIO::SlaveInterface::slaveStatus
void slaveStatus(pid_t, const QByteArray &, const QString &, bool)
KIO::MSG_WRITTEN
Definition: slaveinterface.h:86
KIO::SlaveInterface::error
void error(int, const QString &)
KIO::SlaveInterface::requestNetwork
void requestNetwork(const QString &, const QString &)
Definition: slaveinterface.cpp:359
max_nums
static const unsigned int max_nums
Definition: slaveinterface_p.h:29
kWarning
static QDebug kWarning(bool cond, int area=KDE_DEFAULT_DEBUG_AREA)
qint32
KIO::SlaveInterface::metaData
void metaData(const KIO::MetaData &)
QMap::insert
iterator insert(const Key &key, const T &value)
KIO::SlaveInterface::setOffset
void setOffset(KIO::filesize_t offset)
Definition: slaveinterface.cpp:347
KIO::SlaveInterface::processedSize
void processedSize(KIO::filesize_t)
slavebase.h
KIO::SlaveInterfacePrivate::connection
Connection * connection
Definition: slaveinterface_p.h:47
KIO::INF_GETTING_FILE
Definition: slaveinterface.h:54
QMap< QString, QString >::ConstIterator
typedef ConstIterator
KIO::MSG_ERROR
Definition: slaveinterface.h:70
KIO::MSG_CANRESUME
Definition: slaveinterface.h:82
hostinfo_p.h
KIO::SlaveInterface::dropNetwork
void dropNetwork(const QString &, const QString &)
Definition: slaveinterface.cpp:369
QHostInfo::error
HostInfoError error() const
KIO::SlaveInterface::dispatch
virtual bool dispatch()
Definition: slaveinterface.cpp:80
KIO::MSG_OPENED
Definition: slaveinterface.h:85
KIO::SlaveInterface::messageBox
void messageBox(int type, const QString &text, const QString &caption, const QString &buttonYes, const QString &buttonNo)
Definition: slaveinterface.cpp:398
KIO::CMD_HOST_INFO
Definition: global.h:186
QHostInfo
KIO::MSG_HOST_INFO_REQ
Definition: slaveinterface.h:87
slaveinterface_p.h
KIO::INF_ERROR_PAGE
Definition: slaveinterface.h:52
KIO::SlaveInterface::canResume
void canResume(KIO::filesize_t)
KRecentDirs::list
QStringList list(const QString &fileClass)
Returns a list of directories associated with this file-class.
Definition: krecentdirs.cpp:60
QHostInfo::hostName
QString hostName() const
KIO::INF_MIME_TYPE
Definition: slaveinterface.h:51
This file is part of the KDE documentation.
Documentation copyright © 1996-2020 The KDE developers.
Generated on Mon Jun 22 2020 13:24:54 by doxygen 1.8.7 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 API Reference

Skip menu "kdelibs 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

Search



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