\section{KIO::Job Class Reference}
\label{classKIO_1_1Job}\index{KIO::Job@{KIO::Job}}
The base class for all jobs.  


{\tt \#include $<$jobclasses.h$>$}

Inheritance diagram for KIO::Job:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=164pt]{classKIO_1_1Job__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for KIO::Job:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=277pt]{classKIO_1_1Job__coll__graph}
\end{center}
\end{figure}
\subsection*{Signals}
\begin{CompactItemize}
\item 
void {\bf result} ({\bf KIO::Job} $\ast$job)
\begin{CompactList}\small\item\em Emitted when the job is finished, in any case (completed, canceled, failed...). \item\end{CompactList}\item 
void {\bf canceled} ({\bf KIO::Job} $\ast$job)
\begin{CompactList}\small\item\em Emitted when the job is canceled. \item\end{CompactList}\item 
void {\bf info\-Message} ({\bf KIO::Job} $\ast$, const  {\bf QString} \&msg)
\begin{CompactList}\small\item\em Emitted to display information about this job, as sent by the slave. \item\end{CompactList}\item 
void {\bf connected} ({\bf KIO::Job} $\ast$)
\begin{CompactList}\small\item\em Emitted when the slave successfully connected to the host. \item\end{CompactList}\item 
void {\bf percent} ({\bf KIO::Job} $\ast$job, unsigned long percent)
\begin{CompactList}\small\item\em Progress signal showing the overall progress of the job This is valid for any kind of job, and allows using a a progress bar very easily. \item\end{CompactList}\item 
void {\bf total\-Size} ({\bf KIO::Job} $\ast$, KIO::filesize\_\-t size)
\begin{CompactList}\small\item\em Emitted when we know the size of this job (data size for transfers, number of entries for listings). \item\end{CompactList}\item 
void {\bf processed\-Size} ({\bf KIO::Job} $\ast$, KIO::filesize\_\-t size)
\begin{CompactList}\small\item\em Regularly emitted to show the progress of this job (current data size for transfers, entries listed). \item\end{CompactList}\item 
void {\bf speed} ({\bf KIO::Job} $\ast$, unsigned long bytes\_\-per\_\-second)
\begin{CompactList}\small\item\em Emitted to display information about the speed of this job. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf kill} (bool quietly=true)
\begin{CompactList}\small\item\em Abort this job. \item\end{CompactList}\item 
int {\bf error} () const 
\item 
int {\bf progress\-Id} () const 
\item 
const  {\bf QString} \& {\bf error\-Text} () const 
\item 
{\bf QString} {\bf error\-String} () const 
\begin{CompactList}\small\item\em Converts an error code and a non-i18n error message into an error message in the current language. \item\end{CompactList}\item 
{\bf QString\-List} {\bf detailed\-Error\-Strings} (const  {\bf KURL} $\ast$req\-Url=0L, int method=-1) const 
\begin{CompactList}\small\item\em Converts an error code and a non-i18n error message into i18n strings suitable for presentation in a detailed error message box. \item\end{CompactList}\item 
void {\bf show\-Error\-Dialog} ({\bf QWidget} $\ast${\bf parent}=0L)
\begin{CompactList}\small\item\em Display a dialog box to inform the user of the error given by this job. \item\end{CompactList}\item 
void {\bf set\-Auto\-Error\-Handling\-Enabled} (bool enable, {\bf QWidget} $\ast$parent\-Widget=0)
\begin{CompactList}\small\item\em Enable or disable the automatic error handling. \item\end{CompactList}\item 
bool {\bf is\-Auto\-Error\-Handling\-Enabled} () const 
\begin{CompactList}\small\item\em Returns whether automatic error handling is enabled or disabled. \item\end{CompactList}\item 
void {\bf set\-Window} ({\bf QWidget} $\ast$window)
\begin{CompactList}\small\item\em Associate this job with a window given by {\tt window}. \item\end{CompactList}\item 
{\bf QWidget} $\ast$ {\bf window} () const 
\begin{CompactList}\small\item\em Returns the window this job is associated with. \item\end{CompactList}\item 
void {\bf set\-Parent\-Job} ({\bf Job} $\ast$parent\-Job)
\begin{CompactList}\small\item\em Set the parent {\bf Job}{\rm (p.\,\pageref{classKIO_1_1Job})}. \item\end{CompactList}\item 
{\bf Job} $\ast$ {\bf parent\-Job} () const 
\item 
void {\bf set\-Meta\-Data} (const  KIO::Meta\-Data \&)
\begin{CompactList}\small\item\em Set meta data to be sent to the slave. \item\end{CompactList}\item 
void {\bf add\-Meta\-Data} (const  {\bf QString} \&key, const  {\bf QString} \&value)
\begin{CompactList}\small\item\em Add key/value pair to the meta data that is sent to the slave. \item\end{CompactList}\item 
void {\bf add\-Meta\-Data} (const  {\bf QMap}$<$ {\bf QString}, {\bf QString} $>$ \&values)
\begin{CompactList}\small\item\em Add key/value pairs to the meta data that is sent to the slave. \item\end{CompactList}\item 
void {\bf merge\-Meta\-Data} (const  {\bf QMap}$<$ {\bf QString}, {\bf QString} $>$ \&values)
\begin{CompactList}\small\item\em Add key/value pairs to the meta data that is sent to the slave. \item\end{CompactList}\item 
Meta\-Data {\bf outgoing\-Meta\-Data} () const \label{classKIO_1_1Job_a18}

\item 
Meta\-Data {\bf meta\-Data} () const 
\begin{CompactList}\small\item\em Get meta data received from the slave. \item\end{CompactList}\item 
{\bf QString} {\bf query\-Meta\-Data} (const  {\bf QString} \&key)
\begin{CompactList}\small\item\em Query meta data received from the slave. \item\end{CompactList}\end{CompactItemize}
\subsection*{Protected Slots}
\begin{CompactItemize}
\item 
virtual void {\bf slot\-Result} ({\bf KIO::Job} $\ast$job)
\begin{CompactList}\small\item\em Called whenever a subjob finishes. \item\end{CompactList}\item 
void {\bf slot\-Speed} ({\bf KIO::Job} $\ast$, unsigned long bytes\_\-per\_\-second)
\begin{CompactList}\small\item\em Forward signal from subjob. \item\end{CompactList}\item 
void {\bf slot\-Info\-Message} ({\bf KIO::Job} $\ast$, const  {\bf QString} \&)
\begin{CompactList}\small\item\em Forward signal from subjob. \item\end{CompactList}\item 
void {\bf slot\-Speed\-Timeout} ()
\begin{CompactList}\small\item\em Remove speed information. \item\end{CompactList}\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
{\bf Job} (bool show\-Progress\-Info)\label{classKIO_1_1Job_b0}

\item 
virtual void {\bf add\-Subjob} ({\bf Job} $\ast$job, bool inherit\-Meta\-Data=true)
\begin{CompactList}\small\item\em Add a job that has to be finished before a result is emitted. \item\end{CompactList}\item 
virtual void {\bf remove\-Subjob} ({\bf Job} $\ast$job)
\begin{CompactList}\small\item\em Mark a sub job as being done. \item\end{CompactList}\item 
void {\bf emit\-Percent} (KIO::filesize\_\-t processed\-Size, KIO::filesize\_\-t total\-Size)
\begin{CompactList}\small\item\em Utility function for inherited jobs. \item\end{CompactList}\item 
void {\bf emit\-Speed} (unsigned long bytes\_\-per\_\-second)
\begin{CompactList}\small\item\em Utility function for inherited jobs. \item\end{CompactList}\item 
void {\bf emit\-Result} ()
\begin{CompactList}\small\item\em Utility function to emit the result signal, and suicide this job. \item\end{CompactList}\item 
virtual void {\bf virtual\_\-hook} (int id, void $\ast$data)\label{classKIO_1_1Job_b6}

\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
{\bf QPtr\-List}$<$ {\bf Job} $>$ {\bf subjobs}\label{classKIO_1_1Job_p0}

\item 
int {\bf m\_\-error}\label{classKIO_1_1Job_p1}

\item 
{\bf QString} {\bf m\_\-error\-Text}\label{classKIO_1_1Job_p2}

\item 
unsigned long {\bf m\_\-percent}\label{classKIO_1_1Job_p3}

\item 
int {\bf m\_\-progress\-Id}\label{classKIO_1_1Job_p4}

\item 
{\bf QTimer} $\ast$ {\bf m\_\-speed\-Timer}\label{classKIO_1_1Job_p5}

\item 
{\bf QGuarded\-Ptr}$<$ {\bf QWidget} $>$ {\bf m\_\-window}\label{classKIO_1_1Job_p6}

\item 
Meta\-Data {\bf m\_\-outgoing\-Meta\-Data}\label{classKIO_1_1Job_p7}

\item 
Meta\-Data {\bf m\_\-incoming\-Meta\-Data}\label{classKIO_1_1Job_p8}

\end{CompactItemize}


\subsection{Detailed Description}
The base class for all jobs. 

For all jobs created in an application, the code looks like

\small\begin{alltt}
   KIO::Job * job = KIO::someoperation( some parameters );
   connect( job, SIGNAL( {\bf result( KIO::Job * )}{\rm (p.\,\pageref{classKIO_1_1Job_l0})} ),
            this, SLOT( {\bf slotResult( KIO::Job * )}{\rm (p.\,\pageref{classKIO_1_1Job_j0})} ) );
 \end{alltt}\normalsize 
 (other connects, specific to the job)

And slot\-Result is usually at least:

\small\begin{alltt}
  if ( job-$>${\bf error()}{\rm (p.\,\pageref{classKIO_1_1Job_a2})} )
      job-$>$showErrorDialog( this or 0L  );
 \end{alltt}\normalsize 
 



Definition at line 66 of file jobclasses.h.

\subsection{Member Function Documentation}
\index{KIO::Job@{KIO::Job}!kill@{kill}}
\index{kill@{kill}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KIO::Job::kill (bool {\em quietly} = true)\hspace{0.3cm}{\tt  [virtual]}}\label{classKIO_1_1Job_a1}


Abort this job. 

This kills all subjobs and deletes the job. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em quietly}]if false, {\bf Job}{\rm (p.\,\pageref{classKIO_1_1Job})} will emit signal {\bf result}{\rm (p.\,\pageref{classKIO_1_1Job_l0})} and ask kio\_\-uiserver to close the progress window. {\tt quietly} is set to true for subjobs. Whether applications should call with true or false depends on whether they rely on result being emitted or not. \end{description}
\end{Desc}


Reimplemented in {\bf KIO::Simple\-Job} {\rm (p.\,\pageref{classKIO_1_1SimpleJob_a3})}.

Referenced by KImage\-File\-Preview::clear\-Preview(), and KIO::Progress\-Base::slot\-Stop().\index{KIO::Job@{KIO::Job}!error@{error}}
\index{error@{error}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KIO::Job::error () const\hspace{0.3cm}{\tt  [inline]}}\label{classKIO_1_1Job_a2}


\begin{Desc}
\item[Returns:]the error code for this job, 0 if no error Error codes are defined in {\bf KIO::Error}{\rm (p.\,\pageref{namespaceKIO_a240})}. Only call this method from the slot connected to {\bf result}{\rm (p.\,\pageref{classKIO_1_1Job_l0})}(). \end{Desc}


Definition at line 91 of file jobclasses.h.

Referenced by KIO::Preview\-Job::slot\-Result(), KIO::Delete\-Job::slot\-Result(), KIO::Transfer\-Job::slot\-Result(), and KIO::Chmod\-Job::slot\-Result().\index{KIO::Job@{KIO::Job}!progressId@{progressId}}
\index{progressId@{progressId}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KIO::Job::progress\-Id () const\hspace{0.3cm}{\tt  [inline]}}\label{classKIO_1_1Job_a3}


\begin{Desc}
\item[Returns:]the progress id for this job, as returned by uiserver \end{Desc}


Definition at line 96 of file jobclasses.h.

Referenced by Observer::open\_\-Rename\-Dlg(), Observer::open\_\-Skip\-Dlg(), and Observer::slot\-Transferring().\index{KIO::Job@{KIO::Job}!errorText@{errorText}}
\index{errorText@{errorText}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}const {\bf QString}\& KIO::Job::error\-Text () const\hspace{0.3cm}{\tt  [inline]}}\label{classKIO_1_1Job_a4}


\begin{Desc}
\item[Returns:]a string to help understand the error, usually the url related to the error. Only call if {\bf error}{\rm (p.\,\pageref{classKIO_1_1Job_a2})} is not 0. This is really internal, better use error\-String or error\-Dialog. \end{Desc}


Definition at line 104 of file jobclasses.h.

Referenced by KIO::Transfer\-Job::slot\-Result(), and KIO::Chmod\-Job::slot\-Result().\index{KIO::Job@{KIO::Job}!errorString@{errorString}}
\index{errorString@{errorString}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KIO::Job::error\-String () const}\label{classKIO_1_1Job_a5}


Converts an error code and a non-i18n error message into an error message in the current language. 

The low level (non-i18n) error message (usually a url) is put into the translated error message using 1.

Example for errid == ERR\_\-CANNOT\_\-OPEN\_\-FOR\_\-READING: i18n( \char`\"{}Could not read$\backslash$n\%1\char`\"{} ).arg( errortext ); Use this to display the error yourself, but for a dialog box use {\bf Job::show\-Error\-Dialog}{\rm (p.\,\pageref{classKIO_1_1Job_a7})}. 

Definition at line 173 of file global.cpp.\index{KIO::Job@{KIO::Job}!detailedErrorStrings@{detailedErrorStrings}}
\index{detailedErrorStrings@{detailedErrorStrings}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KIO::Job::detailed\-Error\-Strings (const {\bf KURL} $\ast$ {\em req\-Url} = 0L, int {\em method} = -1) const}\label{classKIO_1_1Job_a6}


Converts an error code and a non-i18n error message into i18n strings suitable for presentation in a detailed error message box. 

{\tt req\-Url} the request URL that generated this error message {\tt method} the method that generated this error message (unimplemented)

Returns strings: caption, error + description, causes+solutions 

Definition at line 383 of file global.cpp.

References QString::arg(), QDate\-Time::current\-Date\-Time(), KStd\-Accel::description(), KLocale::format\-Date\-Time(), QString::from\-Latin1(), KURL::html\-URL(), QString\-List::join(), KGlobal::locale(), and KURL::protocol().\index{KIO::Job@{KIO::Job}!showErrorDialog@{showErrorDialog}}
\index{showErrorDialog@{showErrorDialog}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::show\-Error\-Dialog ({\bf QWidget} $\ast$ {\em parent} = 0L)}\label{classKIO_1_1Job_a7}


Display a dialog box to inform the user of the error given by this job. 

Only call if {\bf error}{\rm (p.\,\pageref{classKIO_1_1Job_a2})} is not 0, and only in the slot connected to {\bf result}{\rm (p.\,\pageref{classKIO_1_1Job_l0})}. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em parent}]the parent widget for the dialog box \end{description}
\end{Desc}


Referenced by KDir\-Lister::handle\-Error().\index{KIO::Job@{KIO::Job}!setAutoErrorHandlingEnabled@{setAutoErrorHandlingEnabled}}
\index{setAutoErrorHandlingEnabled@{setAutoErrorHandlingEnabled}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::set\-Auto\-Error\-Handling\-Enabled (bool {\em enable}, {\bf QWidget} $\ast$ {\em parent\-Widget} = 0)}\label{classKIO_1_1Job_a8}


Enable or disable the automatic error handling. 

When automatic error handling is enabled and an error occurs, then show\-Error\-Dialog is called with the specified parent\-Widget (if supplied) , right before the emission of the result signal.

The default is false.

See also {\bf is\-Auto\-Error\-Handling\-Enabled}{\rm (p.\,\pageref{classKIO_1_1Job_a9})} , {\bf show\-Error\-Dialog}{\rm (p.\,\pageref{classKIO_1_1Job_a7})}

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em enable}]enable or disable automatic error handling \item[{\em parent\-Widget}]the parent widget, passed to {\bf show\-Error\-Dialog}{\rm (p.\,\pageref{classKIO_1_1Job_a7})} \end{description}
\end{Desc}


Referenced by KDir\-Operator::del().\index{KIO::Job@{KIO::Job}!isAutoErrorHandlingEnabled@{isAutoErrorHandlingEnabled}}
\index{isAutoErrorHandlingEnabled@{isAutoErrorHandlingEnabled}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KIO::Job::is\-Auto\-Error\-Handling\-Enabled () const}\label{classKIO_1_1Job_a9}


Returns whether automatic error handling is enabled or disabled. 

See also {\bf set\-Auto\-Error\-Handling\-Enabled}{\rm (p.\,\pageref{classKIO_1_1Job_a8})} . \index{KIO::Job@{KIO::Job}!setWindow@{setWindow}}
\index{setWindow@{setWindow}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::set\-Window ({\bf QWidget} $\ast$ {\em window})}\label{classKIO_1_1Job_a10}


Associate this job with a window given by {\tt window}. 

\index{KIO::Job@{KIO::Job}!window@{window}}
\index{window@{window}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QWidget}$\ast$ KIO::Job::window () const}\label{classKIO_1_1Job_a11}


Returns the window this job is associated with. 

\index{KIO::Job@{KIO::Job}!setParentJob@{setParentJob}}
\index{setParentJob@{setParentJob}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::set\-Parent\-Job ({\bf Job} $\ast$ {\em parent\-Job})}\label{classKIO_1_1Job_a12}


Set the parent {\bf Job}{\rm (p.\,\pageref{classKIO_1_1Job})}. 

One example use of this is when {\bf File\-Copy\-Job}{\rm (p.\,\pageref{classKIO_1_1FileCopyJob})} calls open\_\-Rename\-Dlg, it must pass the correct progress ID of the parent Copy\-Job (to hide the progress dialog). \begin{Desc}
\item[Since:]3.1 \end{Desc}
\index{KIO::Job@{KIO::Job}!parentJob@{parentJob}}
\index{parentJob@{parentJob}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf Job}$\ast$ KIO::Job::parent\-Job () const}\label{classKIO_1_1Job_a13}


\begin{Desc}
\item[See also:]{\bf set\-Parent\-Job}{\rm (p.\,\pageref{classKIO_1_1Job_a12})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}
\index{KIO::Job@{KIO::Job}!setMetaData@{setMetaData}}
\index{setMetaData@{setMetaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::set\-Meta\-Data (const KIO::Meta\-Data \&)}\label{classKIO_1_1Job_a14}


Set meta data to be sent to the slave. 

\index{KIO::Job@{KIO::Job}!addMetaData@{addMetaData}}
\index{addMetaData@{addMetaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::add\-Meta\-Data (const {\bf QString} \& {\em key}, const {\bf QString} \& {\em value})}\label{classKIO_1_1Job_a15}


Add key/value pair to the meta data that is sent to the slave. 



Referenced by KIO::get(), and KIO::Transfer\-Job::slot\-Finished().\index{KIO::Job@{KIO::Job}!addMetaData@{addMetaData}}
\index{addMetaData@{addMetaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::add\-Meta\-Data (const {\bf QMap}$<$ {\bf QString}, {\bf QString} $>$ \& {\em values})}\label{classKIO_1_1Job_a16}


Add key/value pairs to the meta data that is sent to the slave. 

If a certain key already existed, it will be overridden. \index{KIO::Job@{KIO::Job}!mergeMetaData@{mergeMetaData}}
\index{mergeMetaData@{mergeMetaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::merge\-Meta\-Data (const {\bf QMap}$<$ {\bf QString}, {\bf QString} $>$ \& {\em values})}\label{classKIO_1_1Job_a17}


Add key/value pairs to the meta data that is sent to the slave. 

If a certain key already existed, it will remain unchanged. \index{KIO::Job@{KIO::Job}!metaData@{metaData}}
\index{metaData@{metaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}Meta\-Data KIO::Job::meta\-Data () const}\label{classKIO_1_1Job_a19}


Get meta data received from the slave. 

(Valid when first data is received and/or slave is finished) \index{KIO::Job@{KIO::Job}!queryMetaData@{queryMetaData}}
\index{queryMetaData@{queryMetaData}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KIO::Job::query\-Meta\-Data (const {\bf QString} \& {\em key})}\label{classKIO_1_1Job_a20}


Query meta data received from the slave. 

(Valid when first data is received and/or slave is finished) 

Referenced by KIO::Transfer\-Job::slot\-Finished().\index{KIO::Job@{KIO::Job}!result@{result}}
\index{result@{result}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::result ({\bf KIO::Job} $\ast$ {\em job})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l0}


Emitted when the job is finished, in any case (completed, canceled, failed...). 

Use {\bf error}{\rm (p.\,\pageref{classKIO_1_1Job_a2})} to know the result. 

Referenced by KIO::Preview\-Job::available\-Plugins(), KIO::Meta\-Info\-Job::available\-Plugins(), KIO::Preview\-Job::supported\-Mime\-Types(), and KIO::Meta\-Info\-Job::supported\-Mime\-Types().\index{KIO::Job@{KIO::Job}!canceled@{canceled}}
\index{canceled@{canceled}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::canceled ({\bf KIO::Job} $\ast$ {\em job})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l1}


Emitted when the job is canceled. 

{\bf This class or method is obsolete, it is provided for compatibility only.}. Don't use ! Signal {\tt result} is emitted as well, and {\bf error()}{\rm (p.\,\pageref{classKIO_1_1Job_a2})} is, in this case, ERR\_\-USER\_\-CANCELED. \index{KIO::Job@{KIO::Job}!infoMessage@{infoMessage}}
\index{infoMessage@{infoMessage}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::info\-Message ({\bf KIO::Job} $\ast$, const {\bf QString} \& {\em msg})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l2}


Emitted to display information about this job, as sent by the slave. 

Examples of message are \char`\"{}Resolving host\char`\"{}, \char`\"{}Connecting to host...\char`\"{}, etc. 

Referenced by KIO::Simple\-Job::slot\-Info\-Message().\index{KIO::Job@{KIO::Job}!connected@{connected}}
\index{connected@{connected}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::connected ({\bf KIO::Job} $\ast$)\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l3}


Emitted when the slave successfully connected to the host. 

There is no guarantee the slave will send this, and this is currently unused (in the applications). 

Referenced by KIO::Simple\-Job::slot\-Connected().\index{KIO::Job@{KIO::Job}!percent@{percent}}
\index{percent@{percent}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::percent ({\bf KIO::Job} $\ast$ {\em job}, unsigned long {\em percent})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l4}


Progress signal showing the overall progress of the job This is valid for any kind of job, and allows using a a progress bar very easily. 

(see {\bf KProgress}). Note that this signal is not emitted for finished jobs (i.e. percent is never 100). 

Referenced by KIO::Delete\-Job::slot\-Processed\-Size().\index{KIO::Job@{KIO::Job}!totalSize@{totalSize}}
\index{totalSize@{totalSize}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::total\-Size ({\bf KIO::Job} $\ast$, KIO::filesize\_\-t {\em size})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l5}


Emitted when we know the size of this job (data size for transfers, number of entries for listings). 



Referenced by KIO::Simple\-Job::slot\-Total\-Size().\index{KIO::Job@{KIO::Job}!processedSize@{processedSize}}
\index{processedSize@{processedSize}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::processed\-Size ({\bf KIO::Job} $\ast$, KIO::filesize\_\-t {\em size})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l6}


Regularly emitted to show the progress of this job (current data size for transfers, entries listed). 



Referenced by KIO::Delete\-Job::slot\-Processed\-Size(), and KIO::Simple\-Job::slot\-Processed\-Size().\index{KIO::Job@{KIO::Job}!speed@{speed}}
\index{speed@{speed}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::speed ({\bf KIO::Job} $\ast$, unsigned long {\em bytes\_\-per\_\-second})\hspace{0.3cm}{\tt  [signal]}}\label{classKIO_1_1Job_l7}


Emitted to display information about the speed of this job. 

\index{KIO::Job@{KIO::Job}!slotResult@{slotResult}}
\index{slotResult@{slotResult}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KIO::Job::slot\-Result ({\bf KIO::Job} $\ast$ {\em job})\hspace{0.3cm}{\tt  [protected, virtual, slot]}}\label{classKIO_1_1Job_j0}


Called whenever a subjob finishes. 

Default implementation checks for errors and propagates to parent job, then calls {\bf remove\-Subjob}{\rm (p.\,\pageref{classKIO_1_1Job_b2})}. Override if you don't want subjobs errors to be propagated. 

Reimplemented in {\bf KDir\-Size} {\rm (p.\,\pageref{classKDirSize_j0})}, {\bf KIO::Chmod\-Job} {\rm (p.\,\pageref{classKIO_1_1ChmodJob_j0})}, {\bf KIO::Transfer\-Job} {\rm (p.\,\pageref{classKIO_1_1TransferJob_a2})}, {\bf KIO::File\-Copy\-Job} {\rm (p.\,\pageref{classKIO_1_1FileCopyJob_j0})}, {\bf KIO::Delete\-Job} {\rm (p.\,\pageref{classKIO_1_1DeleteJob_j2})}, {\bf KIO::Meta\-Info\-Job} {\rm (p.\,\pageref{classKIO_1_1MetaInfoJob_j0})}, and {\bf KIO::Preview\-Job} {\rm (p.\,\pageref{classKIO_1_1PreviewJob_j0})}.

Referenced by KDir\-Size::slot\-Result().\index{KIO::Job@{KIO::Job}!slotSpeed@{slotSpeed}}
\index{slotSpeed@{slotSpeed}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::slot\-Speed ({\bf KIO::Job} $\ast$, unsigned long {\em bytes\_\-per\_\-second})\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKIO_1_1Job_j1}


Forward signal from subjob. 

\index{KIO::Job@{KIO::Job}!slotInfoMessage@{slotInfoMessage}}
\index{slotInfoMessage@{slotInfoMessage}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::slot\-Info\-Message ({\bf KIO::Job} $\ast$, const {\bf QString} \&)\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKIO_1_1Job_j2}


Forward signal from subjob. 

\index{KIO::Job@{KIO::Job}!slotSpeedTimeout@{slotSpeedTimeout}}
\index{slotSpeedTimeout@{slotSpeedTimeout}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::slot\-Speed\-Timeout ()\hspace{0.3cm}{\tt  [protected, slot]}}\label{classKIO_1_1Job_j3}


Remove speed information. 

\index{KIO::Job@{KIO::Job}!addSubjob@{addSubjob}}
\index{addSubjob@{addSubjob}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KIO::Job::add\-Subjob ({\bf Job} $\ast$ {\em job}, bool {\em inherit\-Meta\-Data} = true)\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKIO_1_1Job_b1}


Add a job that has to be finished before a result is emitted. 

This has obviously to be called before the finish signal is emitted by the slave.

If {\tt inherit\-Meta\-Data} is true, the subjob will inherit the meta data from this job. 

Referenced by KIO::Delete\-Job::slot\-Result().\index{KIO::Job@{KIO::Job}!removeSubjob@{removeSubjob}}
\index{removeSubjob@{removeSubjob}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual void KIO::Job::remove\-Subjob ({\bf Job} $\ast$ {\em job})\hspace{0.3cm}{\tt  [protected, virtual]}}\label{classKIO_1_1Job_b2}


Mark a sub job as being done. 

If it's the last to wait on the job will emit a result - jobs with two steps might want to override slot\-Result in order to avoid calling this method. \index{KIO::Job@{KIO::Job}!emitPercent@{emitPercent}}
\index{emitPercent@{emitPercent}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::emit\-Percent (KIO::filesize\_\-t {\em processed\-Size}, KIO::filesize\_\-t {\em total\-Size})\hspace{0.3cm}{\tt  [protected]}}\label{classKIO_1_1Job_b3}


Utility function for inherited jobs. 

Emits the percent signal if bigger than m\_\-percent, after calculating it from the parameters. 

Referenced by KIO::Simple\-Job::slot\-Processed\-Size().\index{KIO::Job@{KIO::Job}!emitSpeed@{emitSpeed}}
\index{emitSpeed@{emitSpeed}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::emit\-Speed (unsigned long {\em bytes\_\-per\_\-second})\hspace{0.3cm}{\tt  [protected]}}\label{classKIO_1_1Job_b4}


Utility function for inherited jobs. 

Emits the speed signal and starts the timer for removing that info 

Referenced by KIO::Simple\-Job::slot\-Speed().\index{KIO::Job@{KIO::Job}!emitResult@{emitResult}}
\index{emitResult@{emitResult}!KIO::Job@{KIO::Job}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void KIO::Job::emit\-Result ()\hspace{0.3cm}{\tt  [protected]}}\label{classKIO_1_1Job_b5}


Utility function to emit the result signal, and suicide this job. 

It first tells the observer to hide the progress dialog for this job. 

Referenced by KIO::Meta\-Info\-Job::Meta\-Info\-Job(), KIO::Simple\-Job::slot\-Finished(), KIO::Transfer\-Job::slot\-Result(), and KIO::Chmod\-Job::slot\-Result().

The documentation for this class was generated from the following files:\begin{CompactItemize}
\item 
jobclasses.h\item 
global.cpp\end{CompactItemize}
