\section{KProtocol\-Info Class Reference}
\label{classKProtocolInfo}\index{KProtocolInfo@{KProtocolInfo}}
Information about I/O (Internet, etc.) protocols supported by {\bf KDE}.  


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

Inheritance diagram for KProtocol\-Info:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=59pt]{classKProtocolInfo__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for KProtocol\-Info:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=226pt]{classKProtocolInfo__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
typedef {\bf KShared\-Ptr}$<$ {\bf KProtocol\-Info} $>$ {\bf Ptr}\label{classKProtocolInfo_w0}

\item 
enum {\bf Type} \{ {\bf T\_\-STREAM}, 
{\bf T\_\-FILESYSTEM}, 
{\bf T\_\-NONE}, 
{\bf T\_\-ERROR}
 \}
\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf KProtocol\-Info} (const  {\bf QString} \&path)
\begin{CompactList}\small\item\em Read a protocol description file. \item\end{CompactList}\item 
virtual bool {\bf is\-Valid} () const 
\item 
virtual {\bf QString} {\bf name} () const 
\item 
{\bf KProtocol\-Info} ({\bf QData\-Stream} \&\_\-str, int {\bf offset})\label{classKProtocolInfo_a3}

\item 
virtual void {\bf load} ({\bf QData\-Stream} \&)\label{classKProtocolInfo_a5}

\item 
virtual void {\bf save} ({\bf QData\-Stream} \&)\label{classKProtocolInfo_a6}

\end{CompactItemize}
\subsection*{Static Public Member Functions}
\begin{CompactItemize}
\item 
{\bf QString\-List} {\bf protocols} ()
\item 
bool {\bf is\-Known\-Protocol} (const  {\bf KURL} \&url)
\item 
{\bf QString} {\bf exec} (const  {\bf QString} \&protocol)
\item 
Type {\bf input\-Type} (const  {\bf KURL} \&url)
\item 
Type {\bf output\-Type} (const  {\bf KURL} \&url)
\item 
{\bf QString\-List} {\bf listing} (const  {\bf KURL} \&url)
\item 
bool {\bf is\-Source\-Protocol} (const  {\bf KURL} \&url)
\item 
bool {\bf is\-Helper\-Protocol} (const  {\bf KURL} \&url)
\item 
bool {\bf is\-Filter\-Protocol} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Listing} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Reading} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Writing} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Make\-Dir} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Deleting} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Linking} (const  {\bf KURL} \&url)
\item 
bool {\bf supports\-Moving} (const  {\bf KURL} \&url)
\item 
bool {\bf can\-Copy\-From\-File} (const  {\bf KURL} \&url)
\item 
bool {\bf can\-Copy\-To\-File} (const  {\bf KURL} \&url)
\item 
{\bf QString} {\bf default\-Mimetype} (const  {\bf KURL} \&url)
\item 
{\bf QString} {\bf icon} (const  {\bf QString} \&protocol)
\item 
{\bf QString} {\bf config} (const  {\bf QString} \&protocol)
\item 
int {\bf max\-Slaves} (const  {\bf QString} \&protocol)
\item 
bool {\bf determine\-Mimetype\-From\-Extension} (const  {\bf QString} \&protocol)
\item 
Type {\bf input\-Type} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e23}

\item 
Type {\bf output\-Type} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e24}

\item 
{\bf QString\-List} {\bf listing} (const  {\bf QString} \&protocol)
\item 
bool {\bf is\-Source\-Protocol} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e26}

\item 
bool {\bf is\-Helper\-Protocol} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e27}

\item 
bool {\bf is\-Filter\-Protocol} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e28}

\item 
bool {\bf is\-Known\-Protocol} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e29}

\item 
bool {\bf supports\-Listing} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e30}

\item 
bool {\bf supports\-Reading} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e31}

\item 
bool {\bf supports\-Writing} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e32}

\item 
bool {\bf supports\-Make\-Dir} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e33}

\item 
bool {\bf supports\-Deleting} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e34}

\item 
bool {\bf supports\-Linking} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e35}

\item 
bool {\bf supports\-Moving} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e36}

\item 
bool {\bf can\-Copy\-From\-File} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e37}

\item 
bool {\bf can\-Copy\-To\-File} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e38}

\item 
{\bf QString} {\bf default\-Mimetype} (const  {\bf QString} \&protocol)\label{classKProtocolInfo_e39}

\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf virtual\_\-hook} (int id, void $\ast$data)\label{classKProtocolInfo_b0}

\end{CompactItemize}
\subsection*{Protected Attributes}
\begin{CompactItemize}
\item 
{\bf QString} {\bf m\_\-name}\label{classKProtocolInfo_p0}

\item 
{\bf QString} {\bf m\_\-exec}\label{classKProtocolInfo_p1}

\item 
Type {\bf m\_\-input\-Type}\label{classKProtocolInfo_p2}

\item 
Type {\bf m\_\-output\-Type}\label{classKProtocolInfo_p3}

\item 
{\bf QString\-List} {\bf m\_\-listing}\label{classKProtocolInfo_p4}

\item 
bool {\bf m\_\-is\-Source\-Protocol}\label{classKProtocolInfo_p5}

\item 
bool {\bf m\_\-is\-Helper\-Protocol}\label{classKProtocolInfo_p6}

\item 
bool {\bf m\_\-supports\-Listing}\label{classKProtocolInfo_p7}

\item 
bool {\bf m\_\-supports\-Reading}\label{classKProtocolInfo_p8}

\item 
bool {\bf m\_\-supports\-Writing}\label{classKProtocolInfo_p9}

\item 
bool {\bf m\_\-supports\-Make\-Dir}\label{classKProtocolInfo_p10}

\item 
bool {\bf m\_\-supports\-Deleting}\label{classKProtocolInfo_p11}

\item 
bool {\bf m\_\-supports\-Linking}\label{classKProtocolInfo_p12}

\item 
bool {\bf m\_\-supports\-Moving}\label{classKProtocolInfo_p13}

\item 
{\bf QString} {\bf m\_\-default\-Mimetype}\label{classKProtocolInfo_p14}

\item 
bool {\bf m\_\-determine\-Mimetype\-From\-Extension}\label{classKProtocolInfo_p15}

\item 
{\bf QString} {\bf m\_\-icon}\label{classKProtocolInfo_p16}

\item 
bool {\bf m\_\-can\-Copy\-From\-File}\label{classKProtocolInfo_p17}

\item 
bool {\bf m\_\-can\-Copy\-To\-File}\label{classKProtocolInfo_p18}

\item 
{\bf QString} {\bf m\_\-config}\label{classKProtocolInfo_p19}

\item 
int {\bf m\_\-max\-Slaves}\label{classKProtocolInfo_p20}

\end{CompactItemize}
\subsection*{Friends}
\begin{CompactItemize}
\item 
class {\bf KProtocol\-Info\-Factory}\label{classKProtocolInfo_n0}

\end{CompactItemize}


\subsection{Detailed Description}
Information about I/O (Internet, etc.) protocols supported by {\bf KDE}. 

This class is useful if you want to know which protocols {\bf KDE} supports. In addition you can find out lots of information about a certain protocol. KProtocol\-Info scans the $\ast$.protocol files of all installed kioslaves to get this information.

$\ast$.protocol files are installed in the \char`\"{}services\char`\"{} resource.

\begin{Desc}
\item[Author:]Torben Weis $<${\tt weis@kde.org}$>$ \end{Desc}




Definition at line 40 of file kprotocolinfo.h.

\subsection{Constructor \& Destructor Documentation}
\index{KProtocolInfo@{KProtocol\-Info}!KProtocolInfo@{KProtocolInfo}}
\index{KProtocolInfo@{KProtocolInfo}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KProtocol\-Info::KProtocol\-Info (const {\bf QString} \& {\em path})}\label{classKProtocolInfo_a0}


Read a protocol description file. 



Definition at line 35 of file kprotocolinfo.cpp.

References config(), locate(), KConfig\-Base::read\-Bool\-Entry(), KConfig\-Base::read\-Entry(), KConfig\-Base::read\-List\-Entry(), KConfig\-Base::read\-Num\-Entry(), KConfig\-Base::read\-Path\-Entry(), and KConfig\-Base::set\-Group().

\subsection{Member Function Documentation}
\index{KProtocolInfo@{KProtocol\-Info}!isValid@{isValid}}
\index{isValid@{isValid}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual bool KProtocol\-Info::is\-Valid () const\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKProtocolInfo_a1}


\begin{Desc}
\item[Returns:]whether the protocol description file is valid. \end{Desc}


Implements {\bf KSycoca\-Entry}.

Definition at line 57 of file kprotocolinfo.h.

References QString::is\-Empty().\index{KProtocolInfo@{KProtocol\-Info}!name@{name}}
\index{name@{name}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}virtual {\bf QString} KProtocol\-Info::name () const\hspace{0.3cm}{\tt  [inline, virtual]}}\label{classKProtocolInfo_a2}


\begin{Desc}
\item[Returns:]the name of the protocol.\end{Desc}
This corresponds to the \char`\"{}protocol=\char`\"{} field in the protocol description file.

\begin{Desc}
\item[See also:]{\bf KURL::protocol()} \end{Desc}


Implements {\bf KSycoca\-Entry}.

Definition at line 66 of file kprotocolinfo.h.\index{KProtocolInfo@{KProtocol\-Info}!protocols@{protocols}}
\index{protocols@{protocols}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KProtocol\-Info::protocols ()\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e0}


\begin{Desc}
\item[Returns:]list of all known protocols \end{Desc}


Definition at line 177 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!isKnownProtocol@{isKnownProtocol}}
\index{isKnownProtocol@{isKnownProtocol}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::is\-Known\-Protocol (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e1}


\begin{Desc}
\item[Returns:]whether a protocol is installed that is able to handle {\tt url}.\end{Desc}
\begin{Desc}
\item[See also:]{\bf name()}{\rm (p.\,\pageref{classKProtocolInfo_a2})} \end{Desc}


Definition at line 427 of file kprotocolinfo.cpp.

References KURL::protocol().

Referenced by KURLBar::read\-Item().\index{KProtocolInfo@{KProtocol\-Info}!exec@{exec}}
\index{exec@{exec}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KProtocol\-Info::exec (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e2}


\begin{Desc}
\item[Returns:]the library / executable to open for the protocol {\tt protocol} Example : \char`\"{}kio\_\-ftp\char`\"{}, meaning either the executable \char`\"{}kio\_\-ftp\char`\"{} or the library \char`\"{}kio\_\-ftp.la\char`\"{} (recommended), whichever is available.\end{Desc}
This corresponds to the \char`\"{}exec=\char`\"{} field in the protocol description file. 

Definition at line 351 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!inputType@{inputType}}
\index{inputType@{inputType}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KProtocol\-Info::Type KProtocol\-Info::input\-Type (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e3}


\begin{Desc}
\item[Returns:]whether the protocol should be treated as a filesystem or as a stream when reading from it.\end{Desc}
This corresponds to the \char`\"{}input=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}filesystem\char`\"{}, \char`\"{}stream\char`\"{} or \char`\"{}none\char`\"{} (default). 

Definition at line 379 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!outputType@{outputType}}
\index{outputType@{outputType}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}KProtocol\-Info::Type KProtocol\-Info::output\-Type (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e4}


\begin{Desc}
\item[Returns:]whether the protocol should be treated as a filesystem or as a stream when writing to it.\end{Desc}
This corresponds to the \char`\"{}output=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}filesystem\char`\"{}, \char`\"{}stream\char`\"{} or \char`\"{}none\char`\"{} (default). 

Definition at line 388 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!listing@{listing}}
\index{listing@{listing}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KProtocol\-Info::listing (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e5}


\begin{Desc}
\item[Returns:]the list of fields this protocol returns when listing The current possibilities are Name, Type, Size, Date, Access\-Date, Access, Owner, Group, Link, URL, Mime\-Type\end{Desc}
This corresponds to the \char`\"{}listing=\char`\"{} field in the protocol description file. The supported fields should be seperated with ',' in the protocol description file. 

Definition at line 443 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!isSourceProtocol@{isSourceProtocol}}
\index{isSourceProtocol@{isSourceProtocol}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::is\-Source\-Protocol (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e6}


\begin{Desc}
\item[Returns:]whether the protocol can act as a source protocol. TODO: What does that mean? Obsolete? A source protocol retrieves data from or stores data to the location specified by a URL. A source protocol is the opposite of a filter protocol.\end{Desc}
The \char`\"{}source=\char`\"{} field in the protocol description file determines whether a protocol is a source protocol or a filter protocol. Valid values for this field are \char`\"{}true\char`\"{} (default) for source protocol or \char`\"{}false\char`\"{} for filter protocol. 

Definition at line 398 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!isHelperProtocol@{isHelperProtocol}}
\index{isHelperProtocol@{isHelperProtocol}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::is\-Helper\-Protocol (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e7}


\begin{Desc}
\item[Returns:]whether the protocol can act as a helper protocol. TODO: What does that mean?\end{Desc}
This corresponds to the \char`\"{}helper=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 417 of file kprotocolinfo.cpp.

References KURL::protocol().\index{KProtocolInfo@{KProtocol\-Info}!isFilterProtocol@{isFilterProtocol}}
\index{isFilterProtocol@{isFilterProtocol}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::is\-Filter\-Protocol (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e8}


\begin{Desc}
\item[Returns:]whether the protocol can act as a filter protocol. TODO: What does that mean? A filter protocol can operate on data that is passed to it but does not retrieve/store data itself. A filter protocol is the opposite of a source protocol.\end{Desc}
The \char`\"{}source=\char`\"{} field in the protocol description file determines whether a protocol is a source protocol or a filter protocol. Valid values for this field are \char`\"{}true\char`\"{} (default) for source protocol or \char`\"{}false\char`\"{} for filter protocol. 

Definition at line 407 of file kprotocolinfo.cpp.

References KURL::protocol().\index{KProtocolInfo@{KProtocol\-Info}!supportsListing@{supportsListing}}
\index{supportsListing@{supportsListing}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Listing (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e9}


\begin{Desc}
\item[Returns:]whether the protocol can list files/objects. If a protocol supports listing it can be browsed in e.g. file-dialogs and konqueror.\end{Desc}
Whether a protocol supports listing is determined by the \char`\"{}listing=\char`\"{} field in the protocol description file. If the protocol support listing it should list the fields it provides in this field. If the protocol does not support listing this field should remain empty (default.) \begin{Desc}
\item[See also:]{\bf listing()}{\rm (p.\,\pageref{classKProtocolInfo_e5})} \end{Desc}


Definition at line 434 of file kprotocolinfo.cpp.

Referenced by KFile\-Dialog::get\-Start\-URL(), KFile\-Dialog::set\-Selection(), and KURLRequester::slot\-Open\-Dialog().\index{KProtocolInfo@{KProtocol\-Info}!supportsReading@{supportsReading}}
\index{supportsReading@{supportsReading}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Reading (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e10}


\begin{Desc}
\item[Returns:]whether the protocol can retrieve data from URLs.\end{Desc}
This corresponds to the \char`\"{}reading=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 452 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!supportsWriting@{supportsWriting}}
\index{supportsWriting@{supportsWriting}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Writing (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e11}


\begin{Desc}
\item[Returns:]whether the protocol can store data to URLs.\end{Desc}
This corresponds to the \char`\"{}writing=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 461 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!supportsMakeDir@{supportsMakeDir}}
\index{supportsMakeDir@{supportsMakeDir}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Make\-Dir (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e12}


\begin{Desc}
\item[Returns:]whether the protocol can create directories/folders.\end{Desc}
This corresponds to the \char`\"{}makedir=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 470 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!supportsDeleting@{supportsDeleting}}
\index{supportsDeleting@{supportsDeleting}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Deleting (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e13}


\begin{Desc}
\item[Returns:]whether the protocol can delete files/objects.\end{Desc}
This corresponds to the \char`\"{}deleting=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 479 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!supportsLinking@{supportsLinking}}
\index{supportsLinking@{supportsLinking}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Linking (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e14}


\begin{Desc}
\item[Returns:]whether the protocol can create links between files/objects.\end{Desc}
This corresponds to the \char`\"{}linking=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 488 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!supportsMoving@{supportsMoving}}
\index{supportsMoving@{supportsMoving}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::supports\-Moving (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e15}


\begin{Desc}
\item[Returns:]whether the protocol can move files/objects between different locations.\end{Desc}
This corresponds to the \char`\"{}moving=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 497 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!canCopyFromFile@{canCopyFromFile}}
\index{canCopyFromFile@{canCopyFromFile}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::can\-Copy\-From\-File (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e16}


\begin{Desc}
\item[Returns:]whether the protocol can copy files/objects directly from the filesystem itself. If not, the application will read files from the filesystem using the file-protocol and pass the data on to the destination protocol.\end{Desc}
This corresponds to the \char`\"{}copy\-From\-File=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 506 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!canCopyToFile@{canCopyToFile}}
\index{canCopyToFile@{canCopyToFile}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::can\-Copy\-To\-File (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e17}


\begin{Desc}
\item[Returns:]whether the protocol can copy files/objects directly to the filesystem itself. If not, the application will receive the data from the source protocol and store it in the filesystem using the file-protocol.\end{Desc}
This corresponds to the \char`\"{}copy\-To\-File=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} or \char`\"{}false\char`\"{} (default). 

Definition at line 516 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!defaultMimetype@{defaultMimetype}}
\index{defaultMimetype@{defaultMimetype}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KProtocol\-Info::default\-Mimetype (const {\bf KURL} \& {\em url})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e18}


\begin{Desc}
\item[Returns:]default mimetype for this URL based on the protocol\end{Desc}
This corresponds to the \char`\"{}default\-Mimetype=\char`\"{} field in the protocol description file. 

Definition at line 525 of file kprotocolinfo.cpp.

Referenced by KMime\-Type::find\-By\-URL().\index{KProtocolInfo@{KProtocol\-Info}!icon@{icon}}
\index{icon@{icon}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KProtocol\-Info::icon (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e19}


\begin{Desc}
\item[Returns:]the name of the icon, associated with the specified protocol\end{Desc}
This corresponds to the \char`\"{}Icon=\char`\"{} field in the protocol description file. 

Definition at line 306 of file kprotocolinfo.cpp.

References QString::from\-Latin1().

Referenced by KMime\-Type::icon\-For\-URL().\index{KProtocolInfo@{KProtocol\-Info}!config@{config}}
\index{config@{config}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString} KProtocol\-Info::config (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e20}


\begin{Desc}
\item[Returns:]the name of the config file associated with the specified protocol. This is usefull if two similar protocols need to share a single config file, e.g. http and https.\end{Desc}
This corresponds to the \char`\"{}config=\char`\"{} field in the protocol description file. The default is the protocol name, see {\bf name}{\rm (p.\,\pageref{classKProtocolInfo_a2})}() 

Definition at line 315 of file kprotocolinfo.cpp.

Referenced by KProtocol\-Info().\index{KProtocolInfo@{KProtocol\-Info}!maxSlaves@{maxSlaves}}
\index{maxSlaves@{maxSlaves}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}int KProtocol\-Info::max\-Slaves (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e21}


\begin{Desc}
\item[Returns:]the soft limit on the number of slaves for this protocol. This limits the number of slaves used for a single operation, note that multiple operations may result in a number of instances that exceeds this soft limit.\end{Desc}
This corresponds to the \char`\"{}max\-Instances=\char`\"{} field in the protocol description file. The default is 1. 

Definition at line 324 of file kprotocolinfo.cpp.\index{KProtocolInfo@{KProtocol\-Info}!determineMimetypeFromExtension@{determineMimetypeFromExtension}}
\index{determineMimetypeFromExtension@{determineMimetypeFromExtension}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool KProtocol\-Info::determine\-Mimetype\-From\-Extension (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e22}


\begin{Desc}
\item[Returns:]whether mimetypes can be determined based on extension for this protocol. For some protocols, e.g. http, the filename extension in the URL can not be trusted to truly reflect the file type.\end{Desc}
This corresponds to the \char`\"{}determine\-Mimetype\-From\-Extension=\char`\"{} field in the protocol description file. Valid values for this field are \char`\"{}true\char`\"{} (default) or \char`\"{}false\char`\"{}. 

Definition at line 342 of file kprotocolinfo.cpp.

Referenced by KMime\-Type::find\-By\-URL().\index{KProtocolInfo@{KProtocol\-Info}!listing@{listing}}
\index{listing@{listing}!KProtocolInfo@{KProtocol\-Info}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QString\-List} KProtocol\-Info::listing (const {\bf QString} \& {\em protocol})\hspace{0.3cm}{\tt  [static]}}\label{classKProtocolInfo_e25}


\begin{Desc}
\item[Returns:]the list of fields this protocol returns when listing The current possibilities are Name, Type, Size, Date, Access\-Date, Access, Owner, Group, Link, URL, Mime\-Type \end{Desc}


Definition at line 224 of file kprotocolinfo.cpp.

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