\section{DCOPObject Class Reference}
\label{classDCOPObject}\index{DCOPObject@{DCOPObject}}
Provides an interface for receiving DCOP messages.  


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

Inheritance diagram for DCOPObject:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=218pt]{classDCOPObject__inherit__graph}
\end{center}
\end{figure}
Collaboration diagram for DCOPObject:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=55pt]{classDCOPObject__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf DCOPObject} ()
\item 
{\bf DCOPObject} ({\bf QObject} $\ast$obj)
\item 
{\bf DCOPObject} (const {\bf QCString} \&obj\-Id)
\item 
virtual {\bf $\sim$DCOPObject} ()
\item 
{\bf QCString} {\bf obj\-Id} () const 
\item 
bool {\bf set\-Obj\-Id} (const {\bf QCString} \&obj\-Id)
\item 
virtual bool {\bf process} (const {\bf QCString} \&fun, const {\bf QByte\-Array} \&data, {\bf QCString} \&reply\-Type, {\bf QByte\-Array} \&reply\-Data)
\item 
virtual bool {\bf process\-Dynamic} (const {\bf QCString} \&fun, const {\bf QByte\-Array} \&data, {\bf QCString} \&reply\-Type, {\bf QByte\-Array} \&reply\-Data)
\item 
virtual QCString\-List {\bf functions\-Dynamic} ()
\item 
virtual QCString\-List {\bf interfaces\-Dynamic} ()
\item 
virtual QCString\-List {\bf interfaces} ()
\item 
virtual QCString\-List {\bf functions} ()
\item 
void {\bf emit\-DCOPSignal} (const {\bf QCString} \&signal, const {\bf QByte\-Array} \&data)
\item 
bool {\bf connect\-DCOPSignal} (const {\bf QCString} \&sender, const {\bf QCString} \&sender\-Obj, const {\bf QCString} \&signal, const {\bf QCString} \&slot, bool Volatile)
\item 
bool {\bf disconnect\-DCOPSignal} (const {\bf QCString} \&sender, const {\bf QCString} \&sender\-Obj, const {\bf QCString} \&signal, const {\bf QCString} \&slot)
\item 
{\bf DCOPClient} $\ast$ {\bf calling\-Dcop\-Client} ()
\item 
void {\bf set\-Calling\-Dcop\-Client} ({\bf DCOPClient} $\ast$)\label{classDCOPObject_a16}

\end{CompactItemize}
\subsection*{Static Public Member Functions}
\begin{CompactItemize}
\item 
static bool {\bf has\-Object} (const {\bf QCString} \&obj\-Id)
\item 
static {\bf DCOPObject} $\ast$ {\bf find} (const {\bf QCString} \&obj\-Id)
\item 
static {\bf QPtr\-List}$<$ {\bf DCOPObject} $>$ {\bf match} (const {\bf QCString} \&partial\-Id)
\item 
static {\bf QCString} {\bf object\-Name} ({\bf QObject} $\ast$obj)
\end{CompactItemize}
\subsection*{Protected Member Functions}
\begin{CompactItemize}
\item 
virtual void {\bf virtual\_\-hook} (int id, void $\ast$data)\label{classDCOPObject_b0}

\end{CompactItemize}


\subsection{Detailed Description}
Provides an interface for receiving DCOP messages. 

This class provides an interface for receiving DCOP messages. To use it, simply multiply-inherit from DCOPObject and from some other class, and then implement the {\bf DCOPObject::process()}{\rm (p.\,\pageref{classDCOPObject_a6})} method. Because this method is pure virtual, you must implement the method.

Note that it is usually more convenient to mark a section in the class with \char`\"{}k\_\-dcop:\char`\"{}, add your DCOP methods there and let the IDL compiler do the rest. Read the tutorials for more information.

\begin{Desc}
\item[See also:]{\bf DCOPClient}{\rm (p.\,\pageref{classDCOPClient})} 

{\bf DCOPObject\-Proxy}{\rm (p.\,\pageref{classDCOPObjectProxy})} \end{Desc}
\begin{Desc}
\item[Author:]Preston Brown $<${\tt pbrown@kde.org}$>$, Matthias Ettrich $<${\tt ettrich@kde.org}$>$ \end{Desc}




Definition at line 67 of file dcopobject.h.

\subsection{Constructor \& Destructor Documentation}
\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPObject::DCOPObject ()}\label{classDCOPObject_a0}


Creates a DCOPObject and calculates the object id using its physical memory address. 



Definition at line 47 of file dcopobject.cpp.

References QCString::insert(), and QCString::sprintf().\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPObject::DCOPObject ({\bf QObject} $\ast$ {\em obj})}\label{classDCOPObject_a1}


Creates a DCOPObject and calculates the object id using {\bf QObject::name()}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em obj}]the object to extract the name from \end{description}
\end{Desc}


Definition at line 54 of file dcopobject.cpp.

References QCString::insert(), QCString::mid(), QObject::name(), QObject::parent(), and QCString::prepend().\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\index{DCOPObject@{DCOPObject}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPObject::DCOPObject (const {\bf QCString} \& {\em obj\-Id})}\label{classDCOPObject_a2}


Creates a DCOPObject with object Id {\tt obj\-Id}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em obj\-Id}]the object id of the DCOP object \end{description}
\end{Desc}


Definition at line 69 of file dcopobject.cpp.

References QCString::insert(), QCString::is\-Empty(), and QCString::sprintf().\index{DCOPObject@{DCOPObject}!~DCOPObject@{$\sim$DCOPObject}}
\index{~DCOPObject@{$\sim$DCOPObject}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPObject::$\sim${\bf DCOPObject} ()\hspace{0.3cm}{\tt  [virtual]}}\label{classDCOPObject_a3}


Destroys the DCOPObject and removes it from the map of known objects. 



Definition at line 78 of file dcopobject.cpp.

References DCOPClient::disconnect\-DCOPSignal(), DCOPClient::main\-Client(), and obj\-Id().

\subsection{Member Function Documentation}
\index{DCOPObject@{DCOPObject}!objId@{objId}}
\index{objId@{objId}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPObject::obj\-Id () const}\label{classDCOPObject_a4}


Returns the object id of the DCOPObject. 

\begin{Desc}
\item[Returns:]the object's id \end{Desc}


Definition at line 112 of file dcopobject.cpp.

Referenced by connect\-DCOPSignal(), disconnect\-DCOPSignal(), emit\-DCOPSignal(), set\-Obj\-Id(), and $\sim$DCOPObject().\index{DCOPObject@{DCOPObject}!setObjId@{setObjId}}
\index{setObjId@{setObjId}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPObject::set\-Obj\-Id (const {\bf QCString} \& {\em obj\-Id})}\label{classDCOPObject_a5}


Renames a dcop object, if no other with the same name exists Use with care, all dcop signals are disconnected. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em obj\-Id}]the new object id \end{description}
\end{Desc}


Definition at line 98 of file dcopobject.cpp.

References DCOPClient::disconnect\-DCOPSignal(), find(), QCString::insert(), DCOPClient::main\-Client(), and obj\-Id().\index{DCOPObject@{DCOPObject}!process@{process}}
\index{process@{process}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool 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{classDCOPObject_a6}


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{classDCOPObject_a11})} 

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


Reimplemented in {\bf KUnique\-Application}.

Definition at line 166 of file dcopobject.cpp.

References functions(), interfaces(), and process\-Dynamic().\index{DCOPObject@{DCOPObject}!processDynamic@{processDynamic}}
\index{processDynamic@{processDynamic}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPObject::process\-Dynamic (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{classDCOPObject_a7}


This function is of interest when you used an IDL compiler to generate the implementation for {\bf process()}{\rm (p.\,\pageref{classDCOPObject_a6})} but you still want to dispatch some functions dynamically. 

Dynamically means that methods may appear and vanish during runtime.

\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 always false. \end{Desc}
\begin{Desc}
\item[See also:]{\bf process()}{\rm (p.\,\pageref{classDCOPObject_a6})} 

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

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

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


Definition at line 183 of file dcopobject.cpp.

Referenced by process().\index{DCOPObject@{DCOPObject}!functionsDynamic@{functionsDynamic}}
\index{functionsDynamic@{functionsDynamic}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}QCString\-List DCOPObject::functions\-Dynamic ()\hspace{0.3cm}{\tt  [virtual]}}\label{classDCOPObject_a8}


This function is of interest when you used an IDL compiler to generate the implementation for {\bf functions()}{\rm (p.\,\pageref{classDCOPObject_a11})} but you still want to list some functions dynamically. 

Dynamically means that the methods may appear and vanish during runtime.

\begin{Desc}
\item[Returns:]A list of the additional functions, default is an empty list.\end{Desc}
\begin{Desc}
\item[See also:]{\bf functions()}{\rm (p.\,\pageref{classDCOPObject_a11})}, \end{Desc}


Definition at line 193 of file dcopobject.cpp.

Referenced by functions().\index{DCOPObject@{DCOPObject}!interfacesDynamic@{interfacesDynamic}}
\index{interfacesDynamic@{interfacesDynamic}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}QCString\-List DCOPObject::interfaces\-Dynamic ()\hspace{0.3cm}{\tt  [virtual]}}\label{classDCOPObject_a9}


This function is of interest when you used an IDL compiler to generate the implementation for {\bf interfaces()}{\rm (p.\,\pageref{classDCOPObject_a10})} but you still want to list some interfaces dynamically. 

Dynamically means that they may appear and vanish during runtime.

\begin{Desc}
\item[Returns:]A list of the additional interfaces, default is an empty list.\end{Desc}
\begin{Desc}
\item[See also:]{\bf interfaces()}{\rm (p.\,\pageref{classDCOPObject_a10})}, \end{Desc}


Definition at line 187 of file dcopobject.cpp.

Referenced by interfaces().\index{DCOPObject@{DCOPObject}!interfaces@{interfaces}}
\index{interfaces@{interfaces}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}QCString\-List DCOPObject::interfaces ()\hspace{0.3cm}{\tt  [virtual]}}\label{classDCOPObject_a10}


Returns the names of the interfaces, specific ones last. 

The functions 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 explorable.

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


Definition at line 198 of file dcopobject.cpp.

References interfaces\-Dynamic().

Referenced by process().\index{DCOPObject@{DCOPObject}!functions@{functions}}
\index{functions@{functions}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}QCString\-List DCOPObject::functions ()\hspace{0.3cm}{\tt  [virtual]}}\label{classDCOPObject_a11}


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{classDCOPObject_a11})} 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{classDCOPObject_a6})} 

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

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


Definition at line 205 of file dcopobject.cpp.

References functions\-Dynamic(), and QValue\-List::prepend().

Referenced by process().\index{DCOPObject@{DCOPObject}!emitDCOPSignal@{emitDCOPSignal}}
\index{emitDCOPSignal@{emitDCOPSignal}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void DCOPObject::emit\-DCOPSignal (const {\bf QCString} \& {\em signal}, const {\bf QByte\-Array} \& {\em data})}\label{classDCOPObject_a12}


Emit {\tt signal} as DCOP signal from this object with {\tt data} as arguments. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em signal}]the signal to emit \item[{\em data}]the data to send \end{description}
\end{Desc}


Definition at line 213 of file dcopobject.cpp.

References DCOPClient::emit\-DCOPSignal(), DCOPClient::main\-Client(), and obj\-Id().\index{DCOPObject@{DCOPObject}!connectDCOPSignal@{connectDCOPSignal}}
\index{connectDCOPSignal@{connectDCOPSignal}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPObject::connect\-DCOPSignal (const {\bf QCString} \& {\em sender}, const {\bf QCString} \& {\em sender\-Obj}, const {\bf QCString} \& {\em signal}, const {\bf QCString} \& {\em slot}, bool {\em Volatile})}\label{classDCOPObject_a13}


Connects to a DCOP signal. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em sender}]the name of the client that emits the signal. When empty the signal will be passed from any client. \item[{\em sender\-Obj}]the name of the sending object that emits the signal. \item[{\em signal}]the name of the signal. The arguments should match with slot. \item[{\em slot}]The name of the slot to call. Its arguments should match with signal. \item[{\em Volatile}]If true, the connection will not be reestablished when {\tt sender} unregisters and reregisters with DCOP. In this case the {\tt sender} must be registered when the connection is made. If false, the connection will be reestablished when {\tt sender} reregisters. In this case the connection can be made even if {\tt sender} is not registered at that time.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]false if a connection could not be established. This will be the case when \begin{itemize}
\item {\tt Volatile} is true and {\tt sender} does not exist. \item {\tt signal} and {\tt slot} do not have matching arguments. \end{itemize}
\end{Desc}


Definition at line 220 of file dcopobject.cpp.

References DCOPClient::connect\-DCOPSignal(), DCOPClient::main\-Client(), and obj\-Id().\index{DCOPObject@{DCOPObject}!disconnectDCOPSignal@{disconnectDCOPSignal}}
\index{disconnectDCOPSignal@{disconnectDCOPSignal}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPObject::disconnect\-DCOPSignal (const {\bf QCString} \& {\em sender}, const {\bf QCString} \& {\em sender\-Obj}, const {\bf QCString} \& {\em signal}, const {\bf QCString} \& {\em slot})}\label{classDCOPObject_a14}


Disconnects a DCOP signal. 

A special case is when both {\tt sender} \& {\tt signal} are empty. In this case all connections related to this object in the current client are disconnected. (Both connections from as well as to this object!)

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em sender}]the name of the client that emits the signal. \item[{\em sender\-Obj}]the name of the object that emits the signal. If empty all objects will be disconnected. \item[{\em signal}]the name of the signal. The arguments should match with slot. If empty all objects will be disconnected. \item[{\em slot}]The name of the slot the signal is connected to. If empty all slots will be disconnected.\end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]false if no connection(s) where removed. \end{Desc}


Definition at line 234 of file dcopobject.cpp.

References DCOPClient::disconnect\-DCOPSignal(), DCOPClient::main\-Client(), and obj\-Id().\index{DCOPObject@{DCOPObject}!callingDcopClient@{callingDcopClient}}
\index{callingDcopClient@{callingDcopClient}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPClient} $\ast$ DCOPObject::calling\-Dcop\-Client ()}\label{classDCOPObject_a15}


Returns the {\bf DCOPClient}{\rm (p.\,\pageref{classDCOPClient})} responsible for making the call. 

Only call this function while you are handling a DCOP call. \begin{Desc}
\item[Returns:]the {\bf DCOPClient}{\rm (p.\,\pageref{classDCOPClient})} responsible for making the call. This information is only guaranteed to be correct when entering your DCOP function. \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 88 of file dcopobject.cpp.\index{DCOPObject@{DCOPObject}!hasObject@{hasObject}}
\index{hasObject@{hasObject}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPObject::has\-Object (const {\bf QCString} \& {\em obj\-Id})\hspace{0.3cm}{\tt  [static]}}\label{classDCOPObject_e0}


Checks whether an object with the given id is known in this process. 

\begin{Desc}
\item[Returns:]true if an object with the questionable {\tt obj\-Id} is known in this process. This query does not ask proxies.\end{Desc}
{\bf DCOPObject\-Proxy}{\rm (p.\,\pageref{classDCOPObjectProxy})} 

Definition at line 117 of file dcopobject.cpp.\index{DCOPObject@{DCOPObject}!find@{find}}
\index{find@{find}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPObject} $\ast$ DCOPObject::find (const {\bf QCString} \& {\em obj\-Id})\hspace{0.3cm}{\tt  [static]}}\label{classDCOPObject_e1}


Try to find a dcop object with the given id. 

This function does not query the {\bf DCOPObject\-Proxy}{\rm (p.\,\pageref{classDCOPObjectProxy})}. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em obj\-Id}]the object id to search \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the DCOPObject for the id {\tt obj\-Id}. \end{Desc}


Definition at line 125 of file dcopobject.cpp.

References QMap::find().

Referenced by set\-Obj\-Id().\index{DCOPObject@{DCOPObject}!match@{match}}
\index{match@{match}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QPtr\-List}$<$ {\bf DCOPObject} $>$ DCOPObject::match (const {\bf QCString} \& {\em partial\-Id})\hspace{0.3cm}{\tt  [static]}}\label{classDCOPObject_e2}


Tries to find an object using a partial object id. 

This function is used for multicasting a DCOP message to several objects inside a single process.

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em partial\-Id}]the partial object id to search for \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]a list of DCOPObjects beginning with the string contained in {\tt partial\-Id}. \end{Desc}


Definition at line 135 of file dcopobject.cpp.

References QPtr\-List::append().\index{DCOPObject@{DCOPObject}!objectName@{objectName}}
\index{objectName@{objectName}!DCOPObject@{DCOPObject}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPObject::object\-Name ({\bf QObject} $\ast$ {\em obj})\hspace{0.3cm}{\tt  [static]}}\label{classDCOPObject_e3}


Creates an object id for the {\bf QObject} {\tt obj}. 

This is done using the {\bf QObject::name()} function. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em obj}]the object whose name will be used \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the created object id \end{Desc}


Definition at line 146 of file dcopobject.cpp.

References QCString::mid(), QObject::name(), QObject::parent(), and QCString::prepend().

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