\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=49pt]{classDCOPRef__coll__graph}
\end{center}
\end{figure}
\subsection*{Public Types}
\begin{CompactItemize}
\item 
enum {\bf Event\-Loop\-Flag} \{ {\bf No\-Event\-Loop}, 
{\bf Use\-Event\-Loop}
 \}
\end{CompactItemize}
\subsection*{Public Member Functions}
\begin{CompactItemize}
\item 
{\bf DCOPRef} ()
\item 
{\bf DCOPRef} (const {\bf DCOPRef} \&ref)
\item 
{\bf DCOPRef} (const {\bf QCString} \&app, const {\bf QCString} \&obj=\char`\"{}\char`\"{})
\item 
{\bf DCOPRef} ({\bf DCOPObject} $\ast$object)
\item 
{\bf DCOPRef} (const {\bf QCString} \&app, const {\bf QCString} \&obj, const {\bf QCString} \&type)
\item 
bool {\bf is\-Null} () const 
\item 
{\bf QCString} {\bf app} () const 
\item 
{\bf QCString} {\bf obj} () const 
\item 
{\bf QCString} {\bf object} () const 
\item 
{\bf QCString} {\bf type} () const 
\item 
{\bf DCOPRef} \& {\bf operator=} (const {\bf DCOPRef} \&)
\item 
void {\bf set\-Ref} (const {\bf QCString} \&app, const {\bf QCString} \&obj=\char`\"{}\char`\"{})
\item 
void {\bf set\-Ref} (const {\bf QCString} \&app, const {\bf QCString} \&obj, const {\bf QCString} \&type)
\item 
void {\bf clear} ()
\item 
{\bf DCOPClient} $\ast$ {\bf dcop\-Client} () const 
\item 
void {\bf set\-DCOPClient} ({\bf DCOPClient} $\ast$client)
\item 
{\bf DCOPReply} {\bf call} (const {\bf QCString} \&fun)
\item 
{\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop=No\-Event\-Loop, int timeout=-1)
\item 
template$<$class T1$>$ {\bf DCOPReply} {\bf call} (const {\bf QCString} \&fun, const T1 \&t1)
\item 
template$<$class T1$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1)
\item 
template$<$class T1, class T2$>$ {\bf DCOPReply} {\bf call} (const {\bf QCString} \&fun, const T1 \&t1, const T2 \&t2)
\item 
template$<$class T1, class T2$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2)
\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)
\item 
template$<$class T1, class T2, class T3$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3)
\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)
\item 
template$<$class T1, class T2, class T3, class T4$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3, const T4 \&t4)
\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)
\item 
template$<$class T1, class T2, class T3, class T4, class T5$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3, const T4 \&t4, const T5 \&t5)
\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)
\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3, const T4 \&t4, const T5 \&t5, const T6 \&t6)
\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)
\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3, const T4 \&t4, const T5 \&t5, const T6 \&t6, const T7 \&t7)
\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)
\item 
template$<$class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8$>$ {\bf DCOPReply} {\bf call\-Ext} (const {\bf QCString} \&fun, {\bf Event\-Loop\-Flag} use\-Event\-Loop, int timeout, const T1 \&t1, const T2 \&t2, const T3 \&t3, const T4 \&t4, const T5 \&t5, const T6 \&t6, const T7 \&t7, const T8 \&t8)
\item 
bool {\bf send} (const {\bf QCString} \&fun)
\item 
template$<$class T1$>$ bool {\bf send} (const {\bf QCString} \&fun, const T1 \&t1)
\item 
template$<$class T1, class T2$>$ bool {\bf send} (const {\bf QCString} \&fun, const T1 \&t1, const T2 \&t2)
\item 
template$<$class T1, class T2, class T3$>$ bool {\bf send} (const {\bf QCString} \&fun, const T1 \&t1, const T2 \&t2, const T3 \&t3)
\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)
\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)
\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)
\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)
\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)
\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:



\footnotesize\begin{verbatim}    class Example : public DCOPObject
    {
       K_DCOP
    ...
    k_dcop:
       DCOPRef giveMeAnotherObject();
       int doSomething( QString, float, bool );
       ASYNC pingMe( QCString message );
       UserType userFunction( UserType );
    };
\end{verbatim}
\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



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


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



\footnotesize\begin{verbatim}    DCOPRef example( "foo", "example" );
    DCOPReply reply = example.call( "doSomething", QString("Hello World"), (float)2.5, true );
    if ( reply.isValid() ) {
        int result = reply;
        // ...
    }
\end{verbatim}
\normalsize


Note that you must pass a {\bf QString} for the first argument. If you use a regular char pointer, it will be converted to a {\bf QCString}.

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



\footnotesize\begin{verbatim}    QByteArray data, replyData;
    QCString replyType;
    QDataStream arg( data, IO_WriteOnly );
    arg << QString("hello world" ), (float) 2.5 << true;
    if ( DCOPClient::mainClient()->call( app, obj,
                 "doSomething(QString,float,bool)",
                 data, replyType, replyData ) ) {
    if ( replyType == "int" ) {
        int result;
        QDataStream reply( replyData, IO_ReadOnly );
        reply >> result;
        // ...
    }
    }
\end{verbatim}
\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



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


If you use custom data types that do support {\bf QData\-Stream} but have no corresponding 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.



\footnotesize\begin{verbatim}    UserType userType;
    DCOPReply reply = example.call( "userFunction", DCOPArg( userType, "UserType" ) );
\end{verbatim}
\normalsize


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



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


The function {\bf send()}{\rm (p.\,\pageref{classDCOPRef_a34})} 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:



\footnotesize\begin{verbatim}    if ( example.send( "pingMe", "message" ) == false )
       qWarning("could not ping example" );
\end{verbatim}
\normalsize


A DCOP reference operates on {\bf DCOPClient::main\-Client()}{\rm (p.\,\pageref{classDCOPClient_e2})}, unless you explicitly 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 278 of file dcopref.h.

\subsection{Member Enumeration Documentation}
\index{DCOPRef@{DCOPRef}!EventLoopFlag@{EventLoopFlag}}
\index{EventLoopFlag@{EventLoopFlag}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}enum {\bf DCOPRef::Event\-Loop\-Flag}}\label{classDCOPRef_w2}


Flag for allowing entering the event loop if the call blocks too long. 

{\tt No\-Event\-Loop} disables entering the event loop. {\tt Use\-Event\-Loop} allows entering the event loop while waiting for long blocking DCOP call, thus making the GUI repaint if needed, and possibly allowing also other code in the application to be executed. \begin{Desc}
\item[See also:]{\bf DCOPClient::call()}{\rm (p.\,\pageref{classDCOPClient_a20})} \end{Desc}


Definition at line 403 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. 

\begin{Desc}
\item[See also:]{\bf is\-Null()}{\rm (p.\,\pageref{classDCOPRef_a5})} \end{Desc}


Definition at line 105 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 110 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} = {\tt \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 125 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 118 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 130 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 whether this is a null reference. 

\begin{Desc}
\item[Returns:]true if this object is a null reference \end{Desc}
\begin{Desc}
\item[See also:]{\bf clear()}{\rm (p.\,\pageref{classDCOPRef_a13})} \end{Desc}


Definition at line 135 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 140 of file dcopref.cpp.

Referenced by DCOPClient::find\-Object().\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 145 of file dcopref.cpp.\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 150 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 156 of file dcopref.cpp.\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 171 of file dcopref.cpp.

References d.\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} = {\tt \char`\"{}\char`\"{}})}\label{classDCOPRef_a11}


Changes the referenced object. 

Resets the type to unknown (null). The type is not needed for {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})} and {\bf send()}{\rm (p.\,\pageref{classDCOPRef_a34})}. \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 180 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 187 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. 

\begin{Desc}
\item[See also:]{\bf is\-Null()}{\rm (p.\,\pageref{classDCOPRef_a5})} \end{Desc}


Definition at line 194 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 166 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 161 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_a34})} 

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


Definition at line 417 of file dcopref.h.\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}{\bf DCOPReply} DCOPRef::call\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop} = {\tt NoEventLoop}, int {\em timeout} = {\tt -1})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a17}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \item[{\em timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 435 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_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. \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_a34})} 

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


Definition at line 457 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1$>$ {\bf DCOPReply} DCOPRef::call\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop}, int {\em timeout}, const T1 \& {\em t1})\hspace{0.3cm}{\tt  [inline]}}\label{classDCOPRef_a19}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \item[{\em timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \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$>$ {\bf DCOPReply} DCOPRef::call (const {\bf QCString} \& {\em fun}, const T1 \& {\em t1}, const T2 \& {\em t2})\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. \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_a34})} 

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


Definition at line 513 of file dcopref.h.

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


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \item[{\em timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 544 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_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. \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_a34})} 

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


Definition at line 578 of file dcopref.h.

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


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \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 timeout}]timeout for the call in miliseconds, or -1 for no timeout \end{description}
\end{Desc}
\begin{Desc}
\item[Since:]3.2 \end{Desc}


Definition at line 613 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_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. \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_a34})} 

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


Definition at line 651 of file dcopref.h.

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


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \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 timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 690 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_a26}


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_a34})} 

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


Definition at line 732 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!DCOPRef@{DCOPRef}}
\subsubsection{\setlength{\rightskip}{0pt plus 5cm}template$<$class T1, class T2, class T3, class T4, class T5$>$ {\bf DCOPReply} DCOPRef::call\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop}, int {\em timeout}, 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_a27}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \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 timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 775 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_a28}


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_a34})} 

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


Definition at line 821 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!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\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop}, int {\em timeout}, 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_a29}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \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 timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 868 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_a30}


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_a34})} 

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


Definition at line 917 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!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\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop}, int {\em timeout}, 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_a31}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\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 use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \item[{\em timeout}]timeout for the call in miliseconds, or -1 for no timeout \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[Since:]3.2 \end{Desc}


Definition at line 968 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_a32}


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_a34})} 

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


Definition at line 1022 of file dcopref.h.

References QCString::sprintf().\index{DCOPRef@{DCOPRef}!callExt@{callExt}}
\index{callExt@{callExt}!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\-Ext (const {\bf QCString} \& {\em fun}, {\bf Event\-Loop\-Flag} {\em use\-Event\-Loop}, int {\em timeout}, 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}


Like {\bf call()}{\rm (p.\,\pageref{classDCOPRef_a16})}, with additional arguments allowing entering the event loop and specifying timeout. 

\begin{Desc}
\item[Parameters:]
\begin{description}
\item[{\em use\-Event\-Loop}]if Use\-Event\-Loop, the event loop will be started when the call blocks too long \item[{\em timeout}]timeout for the call in miliseconds, or -1 for no timeout \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. \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[Since:]3.2 \end{Desc}


Definition at line 1077 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_a34}


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 1116 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_a35}


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 1138 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_a36}


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 1166 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_a37}


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 1199 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_a38}


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 1236 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_a39}


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 1277 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_a40}


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 1322 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_a41}


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 1371 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_a42}


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 1424 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}
