public KApplication(bool GUIenabled, KComponentData cData)
: this((System.Type) null)
{
CreateProxy();
interceptor.Invoke("KApplication$#", "KApplication(bool, const KComponentData&)", typeof(void), false, typeof(bool), GUIenabled, typeof(KComponentData), cData);
qApp = this;
}
/// <remarks>
/// Add a list of KParts plugins. Convenience method for the one above.
/// If not set explicitly, <code>config</code> is set to componentData.config()
/// </remarks> <short> Add a list of KParts plugins.</short>
public void AddPlugins(KComponentData instance, string categoryName, string categoryKey, KSharedConfig config)
{
interceptor.Invoke("addPlugins#$$?", "addPlugins(const KComponentData&, const QString&, const QString&, const KSharedPtr<KSharedConfig>&)", typeof(void), typeof(KComponentData), instance, typeof(string), categoryName, typeof(string), categoryKey, typeof(KSharedConfig), config);
}
/// <remarks>
/// Queries the KServiceTypeTrader about installed KDataTool implementations.
/// <param> name="datatype" a type that the application can 'export' to the tools (e.g. string)
/// </param><param> name="mimetype" the mimetype of the data (e.g. text/plain)
/// </param><param> name="instance" the application (or the part)'s instance (to check if a tool is excluded from this part,
/// and also used if the tool wants to read its configuration in the app's config file).
/// </param></remarks> <return> the list of results
/// </return>
/// <short> Queries the KServiceTypeTrader about installed KDataTool implementations.</short>
public static List<KDataToolInfo> Query(string datatype, string mimetype, KComponentData instance)
{
return (List<KDataToolInfo>) staticInterceptor.Invoke("query$$#", "query(const QString&, const QString&, const KComponentData&)", typeof(List<KDataToolInfo>), typeof(string), datatype, typeof(string), mimetype, typeof(KComponentData), instance);
}
protected virtual void SetActiveComponent(KComponentData instance)
{
interceptor.Invoke("setActiveComponent#", "setActiveComponent(const KComponentData&)", typeof(void), typeof(KComponentData), instance);
}
public static string ReadConfigFile(string filename, KComponentData componentData)
{
return (string) staticInterceptor.Invoke("readConfigFile$#", "readConfigFile(const QString&, const KComponentData&)", typeof(string), typeof(string), filename, typeof(KComponentData), componentData);
}
/// <remarks>
/// </remarks> <short> </short>
public void SetComponentData(KComponentData componentData)
{
interceptor.Invoke("setComponentData#", "setComponentData(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
}
protected virtual void SetComponentData(KComponentData componentData, bool loadPlugins)
{
interceptor.Invoke("setComponentData#$", "setComponentData(const KComponentData&, bool)", typeof(void), typeof(KComponentData), componentData, typeof(bool), loadPlugins);
}
/// <remarks>
/// Load the Plugins honoring the PluginLoadingMode.
/// If you call this method in an already constructed GUI (like when the user
/// has changed which plugins are enabled) you need to add the new plugins to
/// the KXMLGUIFactory:
/// <pre>
/// if( factory() )
/// {
/// QList<KParts.Plugin > plugins = KParts.Plugin.PluginObjects( this );
/// for(int i = 0; i != plugins.size(); ++i) {
/// factory().AddClient( plugins[i] );
/// }
/// }
/// </pre>
/// </remarks> <short> Load the Plugins honoring the PluginLoadingMode.</short>
protected void LoadPlugins(QObject parent, IKXMLGUIClient parentGUIClient, KComponentData componentData)
{
interceptor.Invoke("loadPlugins###", "loadPlugins(QObject*, KXMLGUIClient*, const KComponentData&)", typeof(void), typeof(QObject), parent, typeof(IKXMLGUIClient), parentGUIClient, typeof(KComponentData), componentData);
}
/// <remarks>
/// Constructor.
/// <param> name="componentName" the name of the component.
/// </param><param> name="catalogName" the name of the translation catalog;
/// if left empty <code>componentName</code> is used
/// </param><param> name="registerAsMain" whether to register the component as the main component
/// of the application. This has no effect, if the application
/// already has a main component.
/// </param></remarks> <short> Constructor.</short>
/// <see> KGlobal.MainComponent</see>
public KComponentData(QByteArray componentName, QByteArray catalogName, KComponentData.MainComponentRegistration registerAsMain)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KComponentData##$", "KComponentData(const QByteArray&, const QByteArray&, KComponentData::MainComponentRegistration)", typeof(void), typeof(QByteArray), componentName, typeof(QByteArray), catalogName, typeof(KComponentData.MainComponentRegistration), registerAsMain);
}
/// <remarks>
/// Copy constructor.
/// It does not copy the data. The data is shared between the old and new objects.
/// </remarks> <short> Copy constructor.</short>
public KComponentData(KComponentData arg1)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KComponentData#", "KComponentData(const KComponentData&)", typeof(void), typeof(KComponentData), arg1);
}
/// <remarks>
/// Constructor.
/// A copy of the aboutData object is made.
/// <param> name="aboutData" data about this component
/// </param><param> name="registerAsMain" whether to register the component as the main component
/// of the application. This has no effect, if the application
/// already has a main component.
/// </param></remarks> <short> Constructor.</short>
/// <see> KGlobal.MainComponent</see>
/// <see> KAboutData</see>
public KComponentData(KAboutData aboutData, KComponentData.MainComponentRegistration registerAsMain)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KComponentData#$", "KComponentData(const KAboutData&, KComponentData::MainComponentRegistration)", typeof(void), typeof(KAboutData), aboutData, typeof(KComponentData.MainComponentRegistration), registerAsMain);
}
public static void LoadPlugins(QObject parent, IKXMLGUIClient parentGUIClient, KComponentData instance)
{
staticInterceptor.Invoke("loadPlugins###", "loadPlugins(QObject*, KXMLGUIClient*, const KComponentData&)", typeof(void), typeof(QObject), parent, typeof(IKXMLGUIClient), parentGUIClient, typeof(KComponentData), instance);
}
public static void LoadPlugins(QObject parent, IKXMLGUIClient parentGUIClient, KComponentData instance, bool enableNewPluginsByDefault)
{
staticInterceptor.Invoke("loadPlugins###$", "loadPlugins(QObject*, KXMLGUIClient*, const KComponentData&, bool)", typeof(void), typeof(QObject), parent, typeof(IKXMLGUIClient), parentGUIClient, typeof(KComponentData), instance, typeof(bool), enableNewPluginsByDefault);
}
public void AddPlugins(KComponentData instance)
{
interceptor.Invoke("addPlugins#", "addPlugins(const KComponentData&)", typeof(void), typeof(KComponentData), instance);
}
public void AddPlugins(KComponentData instance, string categoryName)
{
interceptor.Invoke("addPlugins#$", "addPlugins(const KComponentData&, const QString&)", typeof(void), typeof(KComponentData), instance, typeof(string), categoryName);
}
public KLockFile(string file, KComponentData componentName)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KLockFile$#", "KLockFile(const QString&, const KComponentData&)", typeof(void), typeof(string), file, typeof(KComponentData), componentName);
}
/// <remarks>
/// Construct a new KTemporaryFile. The file will be stored in the temporary
/// directory configured in KDE. The default prefix is the value of the
/// default KDE temporary directory, plus your application's instance name.
/// The default suffix is ".tmp".
/// \param componentData The KComponentData to use for the name of the file and to look up the
/// directory.
/// </remarks> <short> Construct a new KTemporaryFile.</short>
public KTemporaryFile(KComponentData componentData)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KTemporaryFile#", "KTemporaryFile(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
}
/// <remarks>
/// Constructor. Allows specification of a KComponentData other than the default
/// global KComponentData, where needed.
/// </remarks> <short> Constructor.</short>
public KActionCollection(QObject parent, KComponentData cData)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KActionCollection##", "KActionCollection(QObject*, const KComponentData&)", typeof(void), typeof(QObject), parent, typeof(KComponentData), cData);
}
protected virtual void SetComponentData(KComponentData componentData)
{
interceptor.Invoke("setComponentData#", "setComponentData(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
}
/// <remarks>
/// This function is just for convenience. It simply calls
/// instance.Dirs().<see> KStandardDirs.FindResource() findResource</see>(type, filename).
/// <param> name="type" The type of the wanted resource, see KStandardDirs
/// </param><param> name="filename" A relative filename of the resource
/// </param><param> name="cData" The KComponentData object
/// </param></remarks> <return> A full path to the filename specified in the second
/// argument, or string() if not found
/// </return>
/// <short> This function is just for convenience.</short>
public static string Locate(string type, string filename, KComponentData cData)
{
return (string) staticInterceptor.Invoke("locate$$#", "locate(const char*, const QString&, const KComponentData&)", typeof(string), typeof(string), type, typeof(string), filename, typeof(KComponentData), cData);
}
/// <remarks>
/// This function is much like locate. No check is made if the
/// specified filename actually exists. Missing directories
/// are created if <code>createDir</code> is true. If <code>filename</code> is only
/// a directory, without a specific file, <code>filename</code> must have
/// a trailing slash.
/// <param> name="type" The type of the wanted resource, see KStandardDirs
/// </param><param> name="filename" A relative filename of the resource
/// </param><param> name="createDir" If <code>true</code>, missing directories are created,
/// if <code>false</code>, no directory is created
/// </param><param> name="cData" The KComponentData object
/// </param></remarks> <return> A full path to the filename specified in the second
/// argument, or string() if not found
/// </return>
/// <short> This function is much like locate.</short>
public static string LocateLocal(string type, string filename, bool createDir, KComponentData cData)
{
return (string) staticInterceptor.Invoke("locateLocal$$$#", "locateLocal(const char*, const QString&, bool, const KComponentData&)", typeof(string), typeof(string), type, typeof(string), filename, typeof(bool), createDir, typeof(KComponentData), cData);
}
public KConfig(KComponentData componentData, string file, uint mode)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfig#$$", "KConfig(const KComponentData&, const QString&, KConfig::OpenFlags)", typeof(void), typeof(KComponentData), componentData, typeof(string), file, typeof(uint), mode);
}
/// <remarks>
/// Loads an icon <code>icon</code> using the icon loader class of the given componentData <code>componentData.</code>
/// The icon is applied the panel effect as it should only be used to be shown in the
/// system tray.
/// It's commonly used in the form : systray.SetPixmap( systray.LoadIcon( "mysystray" ) );
/// </remarks> <short> Loads an icon <code>icon</code> using the icon loader class of the given componentData <code>componentData.</code></short>
public static QIcon LoadIcon(string icon, KComponentData componentData)
{
return (QIcon) staticInterceptor.Invoke("loadIcon$#", "loadIcon(const QString&, const KComponentData&)", typeof(QIcon), typeof(string), icon, typeof(KComponentData), componentData);
}
public KConfig(KComponentData componentData, string file)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KConfig#$", "KConfig(const KComponentData&, const QString&)", typeof(void), typeof(KComponentData), componentData, typeof(string), file);
}
public static bool SaveConfigFile(QDomDocument doc, string filename, KComponentData componentData)
{
return (bool) staticInterceptor.Invoke("saveConfigFile#$#", "saveConfigFile(const QDomDocument&, const QString&, const KComponentData&)", typeof(bool), typeof(QDomDocument), doc, typeof(string), filename, typeof(KComponentData), componentData);
}
/// <remarks>
/// Constructs an iconloader.
/// <param> name="componentData" the KComponentData to use to create this icon loader.
/// </param> Usually, you use the default iconloader, which can be accessed via
/// KIconLoader.Global(), so you hardly ever have to create an
/// iconloader object yourself. That one is the current KComponentData's
/// (typically KApplication's) iconloader.
/// </remarks> <short> Constructs an iconloader.</short>
public KIconLoader(KComponentData componentData, QObject parent)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KIconLoader##", "KIconLoader(const KComponentData&, QObject*)", typeof(void), typeof(KComponentData), componentData, typeof(QObject), parent);
}
/// <remarks>
/// Create a valid KDataToolInfo.
/// <param> name="service" the corresponding service
/// </param><param> name="instance" the instance to use
/// </param></remarks> <short> Create a valid KDataToolInfo.</short>
public KDataToolInfo(KService service, KComponentData instance)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KDataToolInfo?#", "KDataToolInfo(const KSharedPtr<KService>&, const KComponentData&)", typeof(void), typeof(KService), service, typeof(KComponentData), instance);
}
public KIconLoader(KComponentData componentData)
: this((Type) null)
{
CreateProxy();
interceptor.Invoke("KIconLoader#", "KIconLoader(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
}
/// <remarks>
/// Register a slot to be called when the configuration for the componentData
/// has changed. <code>componentData</code> is the KComponentData object
/// that is passed to KGenericFactory (if it is used). You can query
/// it with KGenericFactory<YourClassName>.ComponentData().
/// componentData.componentName() is also the same name that is put into the
/// .desktop file of the KCMs for the X-KDE-ParentComponents.
/// <param> name="componentData" The KComponentData object
/// </param><param> name="recv" The object that should receive the signal
/// </param><param> name="slot" The slot to be called: "slotName"
/// </param></remarks> <short> Register a slot to be called when the configuration for the componentData has changed.</short>
public static void RegisterComponent(KComponentData componentData, QObject recv, string slot)
{
staticInterceptor.Invoke("registerComponent##$", "registerComponent(const KComponentData&, QObject*, const char*)", typeof(void), typeof(KComponentData), componentData, typeof(QObject), recv, typeof(string), slot);
}
/// <remarks>
/// @brief emit an event
/// This method creates the KNotification, setting every parameter, and fire the event.
/// You don't need to call sendEvent
/// A popup may be displayed or a sound may be played, depending the config.
/// return a KNotification . You may use that pointer to connect some signals or slot.
/// the pointer is automatically deleted when the event is closed.
/// Make sure you use one of the CloseOnTimeOut or CloseWhenWidgetActivated, if not,
/// you have to close yourself the notification.
/// @note the text is shown in a QLabel, you should escape HTML, if needed.
/// <param> name="eventId" is the name of the event
/// </param><param> name="text" is the text of the notification to show in the popup.
/// </param><param> name="pixmap" is a picture which may be shown in the popup.
/// </param><param> name="widget" is a widget where the notification reports to
/// </param><param> name="flags" is a bitmask of NotificationFlag
/// </param><param> name="componentData" used to determine the location of the config file. by default, kapp is used
/// </param></remarks> <short> @brief emit an event </short>
public static KNotification Event(string eventId, string text, QPixmap pixmap, QWidget widget, uint flags, KComponentData componentData)
{
return (KNotification) staticInterceptor.Invoke("event$$##$#", "event(const QString&, const QString&, const QPixmap&, QWidget*, const KNotification::NotificationFlags&, const KComponentData&)", typeof(KNotification), typeof(string), eventId, typeof(string), text, typeof(QPixmap), pixmap, typeof(QWidget), widget, typeof(uint), flags, typeof(KComponentData), componentData);
}