Exemplo n.º 1
0
 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;
 }
Exemplo n.º 2
0
 /// <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);
 }
Exemplo n.º 3
0
 /// <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);
 }
Exemplo n.º 4
0
 protected virtual void SetActiveComponent(KComponentData instance)
 {
     interceptor.Invoke("setActiveComponent#", "setActiveComponent(const KComponentData&)", typeof(void), typeof(KComponentData), instance);
 }
Exemplo n.º 5
0
 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);
 }
Exemplo n.º 6
0
 /// <remarks>
 ///      </remarks>        <short>   </short>
 public void SetComponentData(KComponentData componentData)
 {
     interceptor.Invoke("setComponentData#", "setComponentData(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
 }
Exemplo n.º 7
0
 protected virtual void SetComponentData(KComponentData componentData, bool loadPlugins)
 {
     interceptor.Invoke("setComponentData#$", "setComponentData(const KComponentData&, bool)", typeof(void), typeof(KComponentData), componentData, typeof(bool), loadPlugins);
 }
Exemplo n.º 8
0
 /// <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);
 }
Exemplo n.º 9
0
 /// <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);
 }
Exemplo n.º 10
0
 /// <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);
 }
Exemplo n.º 11
0
 /// <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);
 }
Exemplo n.º 12
0
 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);
 }
Exemplo n.º 13
0
 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);
 }
Exemplo n.º 14
0
 public void AddPlugins(KComponentData instance)
 {
     interceptor.Invoke("addPlugins#", "addPlugins(const KComponentData&)", typeof(void), typeof(KComponentData), instance);
 }
Exemplo n.º 15
0
 public void AddPlugins(KComponentData instance, string categoryName)
 {
     interceptor.Invoke("addPlugins#$", "addPlugins(const KComponentData&, const QString&)", typeof(void), typeof(KComponentData), instance, typeof(string), categoryName);
 }
Exemplo n.º 16
0
 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);
 }
Exemplo n.º 17
0
 /// <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);
 }
Exemplo n.º 18
0
 /// <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);
 }
Exemplo n.º 19
0
 protected virtual void SetComponentData(KComponentData componentData)
 {
     interceptor.Invoke("setComponentData#", "setComponentData(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
 }
Exemplo n.º 20
0
 /// <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);
 }
Exemplo n.º 21
0
 /// <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);
 }
Exemplo n.º 22
0
 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);
 }
Exemplo n.º 23
0
 /// <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);
 }
Exemplo n.º 24
0
 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);
 }
Exemplo n.º 25
0
 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);
 }
Exemplo n.º 26
0
 /// <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);
 }
Exemplo n.º 27
0
 /// <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);
 }
Exemplo n.º 28
0
 public KIconLoader(KComponentData componentData)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("KIconLoader#", "KIconLoader(const KComponentData&)", typeof(void), typeof(KComponentData), componentData);
 }
Exemplo n.º 29
0
 /// <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);
 }
Exemplo n.º 30
0
 /// <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);
 }