\section{My\-DCOPObject Class Reference}
\label{classMyDCOPObject}\index{MyDCOPObject@{MyDCOPObject}}
\$QTDIR/bin/moc {\bf testdcop.cpp}{\rm (p.\,\pageref{testdcop_8cpp})} -o testdcop.moc g++ -o testdcop {\bf testdcop.cpp}{\rm (p.\,\pageref{testdcop_8cpp})} -I\$KDEDIR/include -I\$QTDIR/include -L\$KDEDIR/lib -L\$QTDIR/lib -lkdecore -ldl  


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

Inheritance diagram for My\-DCOPObject:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=89pt]{classMyDCOPObject__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for My\-DCOPObject:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=89pt]{classMyDCOPObject__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Slots}
\begin{CompactItemize}
\item 
void {\bf registered} (const  {\bf QCString} \&app\-Name)\label{classMyDCOPObject_i0}

\item 
void {\bf unregistered} (const  {\bf QCString} \&app\-Name)\label{classMyDCOPObject_i1}

\item 
{\bf QCString\-List} {\bf functions} ()
\begin{CompactList}\small\item\em Returns the list of functions understood by the object. \item\end{CompactList}\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf My\-DCOPObject} (const  {\bf QCString} \&{\bf name})\label{classMyDCOPObject_a0}

\item 
bool {\bf process} (const  {\bf QCString} \&fun, const  {\bf QByte\-Array} \&data, {\bf QCString} \&reply\-Type, {\bf QByte\-Array} \&reply\-Data)
\begin{CompactList}\small\item\em Dispatches a message. \item\end{CompactList}\item 
void {\bf function} (const  {\bf QString} \&arg1, int arg2)\label{classMyDCOPObject_a2}

\end{CompactItemize}


\subsection{Detailed Description}
\$QTDIR/bin/moc {\bf testdcop.cpp}{\rm (p.\,\pageref{testdcop_8cpp})} -o testdcop.moc g++ -o testdcop {\bf testdcop.cpp}{\rm (p.\,\pageref{testdcop_8cpp})} -I\$KDEDIR/include -I\$QTDIR/include -L\$KDEDIR/lib -L\$QTDIR/lib -lkdecore -ldl 



Definition at line 45 of file testdcop.h.

\subsection{Member Function Documentation}
\index{MyDCOPObject@{My\-DCOPObject}!process@{process}}
\index{process@{process}!MyDCOPObject@{My\-DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool My\-DCOPObject::process (const {\bf QCString} \& {\em fun}, const {\bf QByte\-Array} \& {\em data}, {\bf QCString} \& {\em reply\-Type}, {\bf QByte\-Array} \& {\em reply\-Data})\hspace{0.3cm}{\tt  [virtual]}}\label{classMyDCOPObject_a1}


Dispatches a message. 

Usually you want to use an IDL compiler to automatically generate an implementation for this function.

If this function returns false, then {\bf process\-Dynamic}{\rm (p.\,\pageref{classDCOPObject_a7})}() is called.

Note to implementators: remember to call the baseclasses implementation. It handles the functions \char`\"{}functions()\char`\"{} and \char`\"{}interfaces()\char`\"{} which return the lists of supported functions and interfaces, respectively.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]is the normalized function signature. Such a signature usually looks like foobar(QString,int). The return type, qualifiers like \char`\"{}const\char`\"{} etc. are not part of the signature. \item[{\em data}]the received data \item[{\em reply\-Type}]write the reply type in this string \item[{\em reply\-Data}]write the reply data in this array \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]true if successful, false otherwise. The default implementation returns false for all {\tt fun} except \char`\"{}functions()\char`\"{} and \char`\"{}interfaces()\char`\"{}.\end{Desc}
\begin{Desc}
\item[See also:]{\bf DCOPClient::normalize\-Function\-Signature()}{\rm (p.\,\pageref{classDCOPClient_e1})} 

{\bf functions()}{\rm (p.\,\pageref{classMyDCOPObject_i2})} 

{\bf DCOPClient::process()}{\rm (p.\,\pageref{classDCOPClient_a28})} \end{Desc}


Reimplemented from {\bf DCOPObject} {\rm (p.\,\pageref{classDCOPObject_a6})}.

Definition at line 28 of file testdcop.cpp.

References DCOPObject::obj\-Id(), and DCOPObject::process().\index{MyDCOPObject@{My\-DCOPObject}!functions@{functions}}
\index{functions@{functions}!MyDCOPObject@{My\-DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString\-List} My\-DCOPObject::functions ()\hspace{0.3cm}{\tt  [virtual, slot]}}\label{classMyDCOPObject_i2}


Returns the list of functions understood by the object. 

It gets reimplemented by the IDL compiler. If you don't use the IDL compiler, consider implementing this function manually if you want your object to be easily scriptable.

Rationale: {\bf functions()}{\rm (p.\,\pageref{classMyDCOPObject_i2})} allows an interpreter to do client-side type-casting properly.

Note to implementators: remember to call the baseclasses implementation.

\begin{Desc}
\item[Returns:]a list of functions \end{Desc}
\begin{Desc}
\item[See also:]{\bf interfaces()}{\rm (p.\,\pageref{classDCOPObject_a10})} 

{\bf process()}{\rm (p.\,\pageref{classMyDCOPObject_a1})} 

{\bf process\-Dynamic()}{\rm (p.\,\pageref{classDCOPObject_a7})} 

{\bf DCOPClient::normalize\-Function\-Signature()}{\rm (p.\,\pageref{classDCOPClient_e1})} \end{Desc}


Reimplemented from {\bf DCOPObject} {\rm (p.\,\pageref{classDCOPObject_a11})}.

Definition at line 67 of file testdcop.cpp.

References DCOPObject::functions().

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