//Auto-generated by kalyptus. DO NOT EDIT.
package org.trinitydesktop.koala;

import org.trinitydesktop.qt.TQt;
import org.trinitydesktop.qt.TQMetaObject;
import org.trinitydesktop.qt.QtSupport;
import org.trinitydesktop.qt.TQObject;
import java.util.ArrayList;

/**

 Maintains only a single
 instance of a running application at a time.
 If another instance
 is started, it will determine (via DCOP) whether it is the first instance
 or a second instance.  If it is a second instance, it will forward on
 the information to the first instance and then quit.
 The .desktop file for the application should state X-DCOP-ServiceType=Unique,
 see tdeapplication.h
 If your application is used to open files, it should also support the --tempfile
 option (see TDECmdLineArgs.addTempFileOption()), to delete tempfiles after use.
 Add X-TDE-HasTempFileOption=true to the .desktop file to indicate this.
		@author Preston Brown <pbrown@kde.org>

		@short    Maintains only a single  instance of a running application at a time.
		@see TDEApplication
		@see DCOPObject

*/
public class TDEUniqueApplication extends TDEApplication implements DCOPObjectInterface {
	protected TDEUniqueApplication(Class dummy){super((Class) null);}
	public native TQMetaObject metaObject();
	public native String className();
	/**
		 Constructor. Takes command line arguments from TDECmdLineArgs
			@param allowStyles Set to false to disable the loading on plugin based
		 styles. This is only useful to applications that do not display a GUI
		 normally. If you do create an application with <code>allowStyles</code> set to false
		 it normally runs in the background but under special circumstances
		 displays widgets.  Call TDEApplication.enableStyles() before
		 displaying any widgets.
			@param GUIenabled Set to false to disable all GUI stuff. This implies
		 no styles either.
			@param configUnique If true, the uniqueness of the application will
		                 depend on the value of the "MultipleInstances"
		                 key in the "KDE" group of the application config file.
		   		@short    Constructor.
	*/
	public TDEUniqueApplication(boolean allowStyles, boolean GUIenabled, boolean configUnique) {
		super((Class) null);
		newTDEUniqueApplication(allowStyles,GUIenabled,configUnique);
	}
	private native void newTDEUniqueApplication(boolean allowStyles, boolean GUIenabled, boolean configUnique);
	public TDEUniqueApplication(boolean allowStyles, boolean GUIenabled) {
		super((Class) null);
		newTDEUniqueApplication(allowStyles,GUIenabled);
	}
	private native void newTDEUniqueApplication(boolean allowStyles, boolean GUIenabled);
	public TDEUniqueApplication(boolean allowStyles) {
		super((Class) null);
		newTDEUniqueApplication(allowStyles);
	}
	private native void newTDEUniqueApplication(boolean allowStyles);
	public TDEUniqueApplication() {
		super((Class) null);
		newTDEUniqueApplication();
	}
	private native void newTDEUniqueApplication();
	/**
		 Dispatches any incoming DCOP message for a new instance.
			 If it is not a request for a new instance, return false.
		 Overloaded from DCOPObject to make sure that the application
		 stays unique.
			@param fun DCOP function signature
			@param data the data for the arguments
			@param replyType the type of the reply value
			@param replyData the reply
				@short    Dispatches any incoming DCOP message for a new instance.
		@see DCOPObject
	*/
	public native boolean process(String fun, byte[] data, StringBuffer replyType, byte[] replyData);
	/**
		 Creates a new "instance" of the application.
			 Usually this will involve making some calls into the GUI portion of your
		 application asking for a new window to be created, possibly with
		 some data already loaded based on the arguments received.
			 Command line arguments have been passed to TDECmdLineArgs before this
		 function is called and can be checked in the usual way.
			 The default implementation ensures the mainwindow of the already
		 running instance is shown and activated if necessary. You should
		 prefer using it from your overridden method instead of doing
		 it directly.
			 Note that newInstance() is called also in the first started
		 application process.
				@return An exit value. The calling process will exit with this value.

		@short    Creates a new "instance" of the application.
	*/
	public native int newInstance();
	/**
		 Returns whether newInstance() is being called while session
		 restoration is in progress.
				@short    Returns whether newInstance() is being called while session  restoration is in progress.
	*/
	public native boolean restoringSession();
	/**
		 Adds command line options specific for TDEUniqueApplication.
			 Should be called before calling TDEUniqueApplication constructor
		 and / or start().
		   		@short    Adds command line options specific for TDEUniqueApplication.
	*/
	public static native void addCmdLineOptions();
	/**
		 Forks and registers with dcop.
			 The command line arguments are being sent via DCOP to newInstance()
		 and will be received once the application enters the event loop.
			 Typically this is used like:
		 <pre>
		 int main(String[] args) {
		    TDEAboutData about("myappname", "myAppName", .....);
		    TDECmdLineArgs.init(args, &about);
		    TDECmdLineArgs.addCmdLineOptions( myCmdOptions );
		    TDEUniqueApplication.addCmdLineOptions();
			    if (!TDEUniqueApplication.start()) {
		       fprintf(stderr, "myAppName is already running!\n");
		       exit(0);
		    }
		    TDEUniqueApplication a;
		    a.exec();
		 }
		 </pre>
		 Note that it's not necessary to call start() explicitly. It will be
		 called automatically before creating TDEUniqueApplication if it hasn't
		 been called yet, without any performance impact.
				@return true if registration is successful.
         false if another process was already running.

		@short    Forks and registers with dcop.
	*/
	public static native boolean start();
	/**
			   		@short
	*/
	public static native void setHandleAutoStarted();
	/** Deletes the wrapped C++ instance */
	protected native void finalize() throws InternalError;
	/** Delete the wrapped C++ instance ahead of finalize() */
	public native void dispose();
	/** Has the wrapped C++ instance been deleted? */
	public native boolean isDisposed();
	/**
		 Returns the object id of the DCOPObject.
				@return the object's id

		@short    Returns the object id of the DCOPObject.
	*/
	public native String objId();
	/**
		 Renames a dcop object, if no other with the same name exists
		 Use with care, all dcop signals are disconnected
			@param objId the new object id
				@short    Renames a dcop object, if no other with the same name exists  Use with care, all dcop signals are disconnected
	*/
	public native boolean setObjId(String objId);
	/**
		 This function is of interest when you used an IDL compiler
		 to generate the implementation for process() but
		 you still want to dispatch some functions dynamically.
		 Dynamically means that methods may appear and vanish
		 during runtime.
			@param fun is the normalized function signature.
		            Such a signature usually looks like
		            foobar(String,int). The return type,
		            qualifiers like "const" etc. are not part of
		            the signature.
			@param data the received data
			@param replyType write the reply type in this string
			@param replyData write the reply data in this array
				@return true if successful, false otherwise. The default implementation
         returns always false.

		@short    This function is of interest when you used an IDL compiler  to generate the implementation for process() but  you still want to dispatch some functions dynamically.
		@see #process
		@see DCOPClient#normalizeFunctionSignature
		@see #functions
		@see DCOPClient#process
	*/
	public native boolean processDynamic(String fun, byte[] data, StringBuffer replyType, byte[] replyData);
	/**
		 This function is of interest when you used an IDL compiler
		 to generate the implementation for functions() but
		 you still want to list some functions dynamically.
		 Dynamically means that the methods may appear and vanish
		 during runtime.
				@return A list of the additional functions, default is an empty list.

		@short    This function is of interest when you used an IDL compiler  to generate the implementation for functions() but  you still want to list some functions dynamically.
		@see #functions
	*/
	public native ArrayList functionsDynamic();
	/**
		 This function is of interest when you used an IDL compiler
		 to generate the implementation for interfaces() but
		 you still want to list some interfaces dynamically.
		 Dynamically means that they may appear and vanish
		 during runtime.
				@return A list of the additional interfaces, default is an empty list.

		@short    This function is of interest when you used an IDL compiler  to generate the implementation for interfaces() but  you still want to list some interfaces dynamically.
		@see #interfaces
	*/
	public native ArrayList interfacesDynamic();
	/**
		 Returns the names of the interfaces, specific ones last. The
		 functions gets reimplemented by the IDL compiler. If you don't
		 use the IDL compiler, consider implementing this function
		 manually if you want your object to be easily explorable.
				@return a list of interfaces

		@short    Returns the names of the interfaces, specific ones last.
		@see #functions
	*/
	public native ArrayList interfaces();
	/**
		 Returns the list of functions understood by the object. It gets
		 reimplemented by the IDL compiler. If you don't use the IDL
		 compiler, consider implementing this function manually if you
		 want your object to be easily scriptable.
			 Rationale: functions() allows an interpreter to do client-side
		 type-casting properly.
			 Note to implementators: remember to call the baseclasses
		 implementation.
				@return a list of functions

		@short    Returns the list of functions understood by the object.
		@see #interfaces
		@see #process
		@see #processDynamic
		@see DCOPClient#normalizeFunctionSignature
	*/
	public native ArrayList functions();
	/**
		 Emit <code>signal</code> as DCOP signal from this object with <code>data</code> as
		 arguments
			@param signal the signal to emit
			@param data the data to send
		   		@short    Emit <code>signal</code> as DCOP signal from this object with <code>data</code> as  arguments
	*/
	public native void emitDCOPSignal(String signal, byte[] data);
	/**
		 Connects to a DCOP signal.
			@param sender the name of the client that emits the signal. When empty
		 the signal will be passed from any client.
			@param senderObj the name of the sending object that emits the signal.
			@param signal the name of the signal. The arguments should match with slot.
			@param slot The name of the slot to call. Its arguments should match with signal.
			@param Volatile If true, the connection will not be reestablished when
		 <code>sender</code> unregisters and reregisters with DCOP. In this case the <code>sender</code>
		 must be registered when the connection is made.
		 If false, the connection will be reestablished when <code>sender</code> reregisters.
		 In this case the connection can be made even if <code>sender</code> is not registered
		 at that time.

			<li>
			<code>Volatile</code> is true and <code>sender</code>  does not exist.
			</li>

			<li>
			<code>signal</code> and <code>slot</code> do not have matching arguments.

			</li>		@return false if a connection could not be established.
 This will be the case when

		@short    Connects to a DCOP signal.
	*/
	public native boolean connectDCOPSignal(String sender, String senderObj, String signal, String slot, boolean Volatile);
	/**
		 Disconnects a DCOP signal.
			 A special case is when both <code>sender</code> & <code>signal</code> are empty. In this
		 case all connections related to this object in the current client
		 are disconnected. (Both connections from as well as to this object!)
			@param sender the name of the client that emits the signal.
			@param senderObj the name of the object that emits the signal.
		 If empty all objects will be disconnected.
			@param signal the name of the signal. The arguments should match with slot.
		 If empty all objects will be disconnected.
			@param slot The name of the slot the signal is connected to.
		 If empty all slots will be disconnected.
				@return false if no connection(s) where removed.

		@short    Disconnects a DCOP signal.
	*/
	public native boolean disconnectDCOPSignal(String sender, String senderObj, String signal, String slot);
	/**
		 Returns the DCOPClient responsible for making the call.
		 Only call this function while you are handling a DCOP call.
				@return the DCOPClient responsible for making the call.
 This information is only guaranteed to be correct when
 entering your DCOP function.

		@short    Returns the DCOPClient responsible for making the call.
	*/
	public native DCOPClient callingDcopClient();
	/**
				@short
	*/
	public native void setCallingDcopClient(DCOPClient arg1);
	/**
		 Checks whether an object with the given id is known in this process.
			 DCOPObjectProxy
		   		@return true if an object with the questionable <code>objId</code> is
         known in this process. This query does not ask proxies.

		@short    Checks whether an object with the given id is known in this process.
	*/
	public static native boolean hasObject(String objId);
	/**
		 Try to find a dcop object with the given id.
		 This function does not query the DCOPObjectProxy.
			@param objId the object id to search
				@return the  DCOPObject for the id <code>objId.</code>

		@short    Try to find a dcop object with the given id.
	*/
	public static native DCOPObjectInterface find(String objId);
	/**
		 Tries to find an object using a partial object id.
		 This function is used for multicasting a DCOP message to
		 several objects inside a single process.
			@param partialId the partial object id to search for
				@return a list of DCOPObjects beginning with the string
 contained in <code>partialId.</code>

		@short    Tries to find an object using a partial object id.
	*/
	// TQPtrList<DCOPObject> match(const TQCString& arg1); >>>> NOT CONVERTED
	/**
		 Creates an object id for the TQObject <code>obj.</code> This is done
		 using the TQObject.name() function.
			@param obj the object whose name will be used
				@return the created object id

		@short    Creates an object id for the TQObject <code>obj.</code>
	*/
	public static native String objectName(TQObject arg1);
}
