\section{DCOPRef Class Reference}
\label{classDCOPRef}\index{DCOPRef@{DCOPRef}}
A DCOPRef(erence) encapsulates a remote DCOP object as a triple $<$app,obj,type$>$ where type is optional.  


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

Collaboration diagram for DCOPRef:\begin{figure}[H]
\begin{center}
\leavevmode
\includegraphics[width=57pt]{classDCOPRef__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf DCOPRef} ()
\begin{CompactList}\small\item\em Creates a null reference. \item\end{CompactList}\item 
{\bf DCOPRef} (const  {\bf DCOPRef} \&ref)
\begin{CompactList}\small\item\em Copy constructor. \item\end{CompactList}\item 
{\bf DCOPRef} (const  {\bf QCString} \&app, const  {\bf QCString} \&obj=\char`\"{}\char`\"{})
\begin{CompactList}\small\item\em Creates a reference for application {\tt app} and object {\tt obj}. \item\end{CompactList}\item 
{\bf DCOPRef} ({\bf DCOPObject} $\ast$object)
\begin{CompactList}\small\item\em Creates a reference to an existing dcop object. \item\end{CompactList}\item 
{\bf DCOPRef} (const  {\bf QCString} \&app, const  {\bf QCString} \&obj, const  {\bf QCString} \&type)
\begin{CompactList}\small\item\em Creates a reference for application {\tt app} and object {\tt obj} with a specified type {\tt type}. \item\end{CompactList}\item 
bool {\bf is\-Null} () const 
\begin{CompactList}\small\item\em Tests wether it is a null reference. \item\end{CompactList}\item 
{\bf QCString} {\bf app} () const 
\begin{CompactList}\small\item\em Name of the application in which the object resides. \item\end{CompactList}\item 
{\bf QCString} {\bf obj} () const 
\begin{CompactList}\small\item\em Object ID of the referenced object. \item\end{CompactList}\item 
{\bf QCString} {\bf object} () const 
\item 
{\bf QCString} {\bf type} () const 
\begin{CompactList}\small\item\em Type of the referenced object. \item\end{CompactList}\item 
{\bf DCOPRef} \& {\bf operator=} (const  {\bf DCOPRef} \&)
\begin{CompactList}\small\item\em Assignment operator. \item\end{CompactList}\item 
void {\bf set\-Ref} (const  {\bf QCString} \&app, const  {\bf QCString} \&obj=\char`\"{}\char`\"{})
\begin{CompactList}\small\item\em Changes the referenced object. \item\end{CompactList}\item 
void {\bf set\-Ref} (const  {\bf QCString} \&app, const  {\bf QCString} \&obj, const  {\bf QCString} \&type)
\begin{CompactList}\small\item\em Changes the referenced object. \item\end{CompactList}\item 
void {\bf clear} ()
\begin{CompactList}\small\item\em Makes this a null reference. \item\end{CompactList}\item 
{\bf DCOPClient} $\ast$ {\bf dcop\-Client} () const 
\begin{CompactList}\small\item\em Returns the dcop client the reference operates on. \item\end{CompactList}\item 
void {\bf set\-DCOPClient} ({\bf DCOPClient} $\ast$client)
\begin{CompactList}\small\item\em Sets a specific dcop client for this reference. \item\end{CompactList}\item 
{\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6, const  T7 \&t7)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8$>$ {\bf DCOPReply} {\bf call} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6, const  T7 \&t7, const  T8 \&t8)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
bool {\bf send} (const  {\bf QCString} \&fun)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6, const  T7 \&t7)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8$>$ bool {\bf send} (const  {\bf QCString} \&fun, const  T1 \&t1, const  T2 \&t2, const  T3 \&t3, const  T4 \&t4, const  T5 \&t5, const  T6 \&t6, const  T7 \&t7, const  T8 \&t8)
\begin{CompactList}\small\item\em Calls the function {\tt fun} on the object referenced by this reference. \item\end{CompactList}\end{CompactItemize}


\subsection{Detailed Description}
A DCOPRef(erence) encapsulates a remote DCOP object as a triple $<$app,obj,type$>$ where type is optional. 

It allows for calling and passing DCOP objects.

A DCOP reference makes it possible to return references to other DCOP objects in a DCOP interface, for example in the method give\-Me\-Another\-Object() in an interface like this:

\small\begin{alltt}
	class Example : public {\bf DCOPObject}{\rm (p.\,\pageref{classDCOPObject})}
	\{
	   K\_DCOP
	...
	k\_dcop:
	   DCOPRef giveMeAnotherObject();
	   int doSomething( QString, float, bool );
	   ASYNC pingMe( QCString message );
	   UserType userFunction( UserType );
	\};
 \end{alltt}\normalsize 


In addition, the reference can operate as a comfortable generic stub to call remote DCOP objects in cases where no {\bf DCOPStub}{\rm (p.\,\pageref{classDCOPStub})} is available. The advantage of using DCOPRef instead of the low-level functions {\bf DCOPClient::call()}{\rm (p.\,\pageref{classDCOPClient_a20})} and {\bf DCOPClient::send()}{\rm (p.\,\pageref{classDCOPClient_a18})} are the nicer syntax and the implicit runtime error checking.

Say you want to call the method \char`\"{}do\-Something\char`\"{} from the above interface on an object called \char`\"{}example\char`\"{} that lives in application \char`\"{}foo\char`\"{}. Using DCOPRef, you would write

\small\begin{alltt}
	DCOPRef example( "foo", "example" );
	int result = example.call( "doSomething", "Hello World", (float)2.5, true );
 \end{alltt}\normalsize 


If it is important for you to know whether the call succeeded or not, you can use the slightly more elaborate pattern:

\small\begin{alltt}
	DCOPRef example( "foo", "example" );
	{\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} reply = example.call( "doSomething", "Hello World", (float)2.5, true );
	if ( reply.isValid() ) \{
	    int result = reply;
	    // ...
	\}
 \end{alltt}\normalsize 


For curiosity, here is how you would achieve the exactly same functionality by using {\bf DCOPClient::call()}{\rm (p.\,\pageref{classDCOPClient_a20})} directly:

\small\begin{alltt}
    {\bf QByteArray} data, replyData;
    {\bf QCString} replyType;
    {\bf QDataStream} arg( data, IO\_WriteOnly );
    arg $<$$<$ {\bf QString}("hello world" ), (float) 2.5 $<$$<$ true;
    if ( {\bf DCOPClient::mainClient()}{\rm (p.\,\pageref{classDCOPClient_e2})}-$>$call( app, obj,
			     "doSomething(QString,float,bool)",
			     data, replyType, replyData ) ) \{
	if ( replyType == "int" ) \{
	    int result;
	    {\bf QDataStream} reply( replyData, IO\_ReadOnly );
	    reply $>$$>$ result;
	    // ...
	\}
    \}
 \end{alltt}\normalsize 


As you might see from the code snippet, the DCOPRef has to \char`\"{}guess\char`\"{} the names of the datatypes of the arguments to construct a dcop call. This is done through global inline overloads of the dcop\-Type\-Name function, for example

\small\begin{alltt}
	inline const char* dcopTypeName( const QString& ) \{ return "QString"; \}
 \end{alltt}\normalsize 


If you use custom data types that do support {\bf QData\-Stream} but have no corrsponding dcop\-Type\-Name overload, you can either provide such an overload or use a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} wrapper that allows you to specify the type.

\small\begin{alltt}
	UserType userType;
	{\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} reply = example.call( "userFunction", {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})}( userType, "UserType" ) );
 \end{alltt}\normalsize 


Similar, when you retrieve such a data type, you can use an explicit call to {\bf DCOPReply::get()}{\rm (p.\,\pageref{classDCOPReply_a1})}:

\small\begin{alltt}
	UserType userType;
	reply.get( userType, "UserType" );
 \end{alltt}\normalsize 


The function {\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} works very similar to {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, only that it returns a simple bool on whether the signal could be sent or not:

\small\begin{alltt}
	if ( example.pingMe( "message" ) == false )
	   qWarning("could not ping example" );
 \end{alltt}\normalsize 


A DCOP reference operates on {\bf DCOPClient::main\-Client()}{\rm (p.\,\pageref{classDCOPClient_e2})}, unless you explicitely specify another client with {\bf set\-DCOPClient()}{\rm (p.\,\pageref{classDCOPRef_a15})}.

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

{\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} 

{\bf DCOPObject}{\rm (p.\,\pageref{classDCOPObject})} \end{Desc}
\begin{Desc}
\item[Author:]Matthias Ettrich $<${\tt ettrich@kde.org}$>$, Torben Weis $<${\tt weis@kde.org}$>$ \end{Desc}




Definition at line 275 of file dcopref.h.

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


Creates a null reference. 



Definition at line 91 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPRef::DCOPRef (const {\bf DCOPRef} \& {\em ref})}\label{classDCOPRef_a1}


Copy constructor. 



Definition at line 96 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPRef::DCOPRef (const {\bf QCString} \& {\em app}, const {\bf QCString} \& {\em obj} = \char`\"{}\char`\"{})}\label{classDCOPRef_a2}


Creates a reference for application {\tt app} and object {\tt obj}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em app}]The name of an application as registered by the dcopserver. \item[{\em obj}]The name of the dcop object. \end{description}
\end{Desc}


Definition at line 111 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPRef::DCOPRef ({\bf DCOPObject} $\ast$ {\em object})}\label{classDCOPRef_a3}


Creates a reference to an existing dcop object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em object}]The dcop object to create the ref to. \end{description}
\end{Desc}


Definition at line 104 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\index{DCOPRef@{DCOPRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}DCOPRef::DCOPRef (const {\bf QCString} \& {\em app}, const {\bf QCString} \& {\em obj}, const {\bf QCString} \& {\em type})}\label{classDCOPRef_a4}


Creates a reference for application {\tt app} and object {\tt obj} with a specified type {\tt type}. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em app}]The name of an application as registered by the dcopserver. \item[{\em obj}]The name of the dcop object \item[{\em type}]The object's type \end{description}
\end{Desc}


Definition at line 116 of file dcopref.cpp.

\subsection{Member Function Documentation}
\index{DCOPRef@{DCOPRef}!isNull@{isNull}}
\index{isNull@{isNull}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPRef::is\-Null () const}\label{classDCOPRef_a5}


Tests wether it is a null reference. 

\begin{Desc}
\item[Returns:]true if this object is a null reference \end{Desc}


Definition at line 121 of file dcopref.cpp.

References QCString::is\-Null().\index{DCOPRef@{DCOPRef}!app@{app}}
\index{app@{app}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPRef::app () const}\label{classDCOPRef_a6}


Name of the application in which the object resides. 

\begin{Desc}
\item[Returns:]the application's id. Can be null or empty if not set. \end{Desc}


Definition at line 126 of file dcopref.cpp.

Referenced by operator=().\index{DCOPRef@{DCOPRef}!obj@{obj}}
\index{obj@{obj}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPRef::obj () const}\label{classDCOPRef_a7}


Object ID of the referenced object. 

\begin{Desc}
\item[Returns:]the id of the referenced object. Can be null or empty if not set. \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 131 of file dcopref.cpp.

Referenced by operator=().\index{DCOPRef@{DCOPRef}!object@{object}}
\index{object@{object}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPRef::object () const}\label{classDCOPRef_a8}


\begin{Desc}
\item[{\bf Deprecated}]\end{Desc}


Definition at line 136 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!type@{type}}
\index{type@{type}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf QCString} DCOPRef::type () const}\label{classDCOPRef_a9}


Type of the referenced object. 

May be null (i.e. unknown). \begin{Desc}
\item[Returns:]the type of the referenced object, or null if unknown \end{Desc}


Definition at line 142 of file dcopref.cpp.

Referenced by operator=().\index{DCOPRef@{DCOPRef}!operator=@{operator=}}
\index{operator=@{operator=}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPRef} \& DCOPRef::operator= (const {\bf DCOPRef} \&)}\label{classDCOPRef_a10}


Assignment operator. 

Copies the references data. 

Definition at line 157 of file dcopref.cpp.

References app(), d, obj(), and type().\index{DCOPRef@{DCOPRef}!setRef@{setRef}}
\index{setRef@{setRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void DCOPRef::set\-Ref (const {\bf QCString} \& {\em app}, const {\bf QCString} \& {\em obj} = \char`\"{}\char`\"{})}\label{classDCOPRef_a11}


Changes the referenced object. 

Resets the type to unknown (null). \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em app}]the application id. \item[{\em obj}]the object id \end{description}
\end{Desc}


Definition at line 166 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!setRef@{setRef}}
\index{setRef@{setRef}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void DCOPRef::set\-Ref (const {\bf QCString} \& {\em app}, const {\bf QCString} \& {\em obj}, const {\bf QCString} \& {\em type})}\label{classDCOPRef_a12}


Changes the referenced object. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em app}]the application id. \item[{\em obj}]the object id \item[{\em type}]the object's type \end{description}
\end{Desc}


Definition at line 173 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!clear@{clear}}
\index{clear@{clear}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void DCOPRef::clear ()}\label{classDCOPRef_a13}


Makes this a null reference. 



Definition at line 180 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!dcopClient@{dcopClient}}
\index{dcopClient@{dcopClient}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPClient} $\ast$ DCOPRef::dcop\-Client () const}\label{classDCOPRef_a14}


Returns the dcop client the reference operates on. 

If no client has been set, this is the {\bf DCOPClient::main\-Client()}{\rm (p.\,\pageref{classDCOPClient_e2})}. \begin{Desc}
\item[Returns:]the {\bf DCOPClient}{\rm (p.\,\pageref{classDCOPClient})} of this object \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 152 of file dcopref.cpp.

References DCOPClient::main\-Client().\index{DCOPRef@{DCOPRef}!setDCOPClient@{setDCOPClient}}
\index{setDCOPClient@{setDCOPClient}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}void DCOPRef::set\-DCOPClient ({\bf DCOPClient} $\ast$ {\em client})}\label{classDCOPRef_a15}


Sets a specific dcop client for this reference. 

Otherwise {\bf DCOPClient::main\-Client()}{\rm (p.\,\pageref{classDCOPClient_e2})} is used. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em client}]the new {\bf DCOPClient}{\rm (p.\,\pageref{classDCOPClient})} of this object \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 147 of file dcopref.cpp.\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a16}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 401 of file dcopref.h.\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a17}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 422 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a18}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 450 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a19}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 483 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a20}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 520 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a21}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 561 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a22}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 606 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6}, const T7 \& {\em t7})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a23}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t7}]the seventh argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 655 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!call@{call}}
\index{call@{call}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6}, const T7 \& {\em t7}, const T8 \& {\em t8})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a24}


Calls the function {\tt fun} on the object referenced by this reference. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t7}]the seventh argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t8}]the eigth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf send()}{\rm (p.\,\pageref{classDCOPRef_a25})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 708 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}bool DCOPRef::send (const {\bf QCString} \& {\em fun})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a25}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 746 of file dcopref.h.\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a26}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 768 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a27}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 796 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a28}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 829 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a29}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 866 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a30}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 907 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a31}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 952 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6}, const T7 \& {\em t7})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a32}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t7}]the seventh argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 1001 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!send@{send}}
\index{send@{send}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8$>$ bool DCOPRef::send (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2}, const T3 \& {\em t3}, const T4 \& {\em t4}, const T5 \& {\em t5}, const T6 \& {\em t6}, const T7 \& {\em t7}, const T8 \& {\em t8})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a33}


Calls the function {\tt fun} on the object referenced by this reference. 

Unlike {\bf call}{\rm (p.\,\pageref{classDCOPRef_a16})}() this method does not expect a return value. \begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em fun}]the name of the DCOP function. This can be either the full function signature (e.g. \char`\"{}set\-Name(QString)\char`\"{}) or only the function's name (e.g. \char`\"{}set\-Name\char`\"{}). In the latter case the exact signature will be guessed from the arguments \item[{\em t1}]the first argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t2}]the second argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t3}]the third argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t4}]the fourth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t5}]the fifth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t6}]the sixth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t7}]the seventh argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \item[{\em t8}]the eigth argument of the function. This can be a supported base type or a {\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} object. \end{description}
\end{Desc}
\begin{Desc}
\item[Returns:]the {\bf DCOPReply}{\rm (p.\,\pageref{classDCOPReply})} object. Is invalid ({\bf DCOPReply::is\-Valid}{\rm (p.\,\pageref{classDCOPReply_a3})}()) when an error occurred. \end{Desc}
\begin{Desc}
\item[See also:]{\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} 

{\bf DCOPArg}{\rm (p.\,\pageref{classDCOPArg})} \end{Desc}
\begin{Desc}
\item[Since:]3.1 \end{Desc}


Definition at line 1054 of file dcopref.h.

References QCString::sprintf().

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