Activates the extension on the given object. The #GObject on which the plugin should be activated. Deactivates the plugin on the given object. A #GObject. Triggers an update of the plugin's internal state to take into account state changes in the targetted object, due to a plugin or user action. A #GObject. Activates the extension on the given object. The #GObject on which the plugin should be activated. Deactivates the plugin on the given object. A #GObject. Triggers an update of the plugin's internal state to take into account state changes in the targetted object, due to a plugin or user action. A #GObject. The #GObject on which the plugin should be activated. A #GObject. A #GObject. Engine at the heart of the Peas plugin system. Returns a new #PeasEngine object. See the properties description for more information about the parameters. a newly created #PeasEngine object. The name of the application The base directory for language modules The paths where to look for plugins Disable a loader, avoiding using the plugins written using the related language to be loaded. This method must be called before any plugin relying on the loader @loader_id has been loaded. For instance, the following code will prevent any python plugin from being loaded: |[ peas_engine_disable_loader (engine, "python"); ]| The id of the loader to inhibit. Rescan all the registered directories to find new or updated plugins. Calling this function will make the newly installed plugin infos to be loaded by the engine, so the new plugins can actually be used without restarting the application. Returns the list of #PeasPluginInfo known to the engine. #PeasPluginInfo. Note that the list belongs to the engine and should not be freed. a #GList of Returns the list of the names of all the loaded plugins, or %NULL if there is no plugin currently loaded. Please note that the returned array is a A newly-allocated NULL-terminated array of strings, or %NULL. Sets the list of loaded plugins for @engine. When this function is called, the #PeasEngine will load all the plugins whose names are in @plugin_names, and ensures all other active plugins are unloaded. A %NULL-terminated array of plugin names. the #PeasPluginInfo corresponding with a given plugin name. A plugin name. Loads the plugin corresponding to @info if it's not currently loaded. whether the plugin has been successfuly loaded. A #PeasPluginInfo. Unloads the plugin corresponding to @info. whether the plugin has been successfuly unloaded. A #PeasPluginInfo. This function triggers garbage collection on all the loaders currently owned by the #PeasEngine. This can be used to force the loaders to destroy managed objects that still hold references to objects that are about to disappear. The application name. Filename extension and section header for #PeasPluginInfo files are actually derived from this value. For instance, if app-name is "Gedit", then info files will have the .gedit-plugin extension, and the engine will look for a "Gedit Plugin" section in it to load the plugin data. The base application directory for binding modules lookup. Each loader module will load its modules from a subdirectory of the base module directory. For instance, the python loader will look for python modules in "${base-module-dir}/python/". The list of path where to look for plugins. A so-called "search path" actually consists on a couple of both a module directory (where the shared libraries or language modules lie) and a data directory (where the plugin data is). The #PeasPlugin will be able to use a correct data dir depending on where it is installed, hence allowing to keep the plugin agnostic installed both in the system path or in the user's home directory, without taking other special care than using egg_plugin_get_data_dir() when looking for its data files. Concretely, this property contains a NULL-terminated array of strings, whose even-indexed strings are module directories, and odd-indexed ones are the associated data directories. Here is an example of such an array: |[ gchar const * const search_paths[] = { // Plugins in ~/.config g_build_filename (g_get_user_config_dir (), "example/plugins", NULL), g_build_filename (g_get_user_config_dir (), "example/plugins", NULL), // System plugins EXAMPLE_PREFIX "/lib/example/plugins/", EXAMPLE_PREFIX "/share/example/plugins/", NULL }; ]| The load-plugin signal is emitted when a plugin is being loaded. A #PeasPluginInfo. The unload-plugin signal is emitted when a plugin is being unloaded. A #PeasPluginInfo. Base class for plugins. Call a method of the object behind @extension. %TRUE on successful call. the name of the method that should be called. Base class for C extensions. Get information relative to @extbase. the #PeasPluginInfo relative to the #PeasExtensionBase. Get the path of the directory where the plugin should look for its data files. directory where the plugin should look for its data files A newly allocated string with the path of the Create an #ExtensionSet for all the @exten_type extensions defined in the plugins loaded in @engine. A #PeasEngine. the extension #GType. Call a method on all the #PeasExtension instances contained in @set. %TRUE on successful call. the name of the method that should be called. Register an implementation for an extension type through a factory function @factory_func which will instantiate the extension when requested. This method is primarily meant to be used by native bindings (like gtkmm), creatint native types which cannot be instantiated correctly using g_object_new(). For other uses, you will usually prefer relying on peas_object_module_register_extension_type(). The #GType of the extension interface you implement. The #PeasFactoryFunc that will create the @iface_type instance when requested. Data to pass to @func calls. A #GDestroyNotify for @user_data. Register an extension type which implements the extension interface The #GType of the extension interface you implement. The #GType of your implementation of @iface_type. Boxed type for the information related to a plugin. Check if the plugin is loaded. %TRUE if the plugin is loaded. Check if the plugin is available. A plugin is marked as not available when there is no loader available to load it, or when there has been an error when trying to load it previously. %TRUE if the plugin is available. Gets the module name. the module name. Gets the module directory. the module directory. Gets the data dir of the plugin. the plugin's data dir. Gets the name of the plugin. the plugin's name. Gets the description of the plugin. the plugin's description. Gets a NULL-terminated array of strings with the authors of the plugin. the plugin's author list. Gets the website of the plugin. the plugin's associated website. Gets the copyright of the plugin. the plugin's copyright information. Gets the version of the plugin. the plugin's version. Gets the interface age of the plugin. the interface age of the plugin or %0 if not known. Gets a hash table of string keys present and #GValue values, present in the plugin information file, but not handled by libpeas. Note that libpeas only handles booleans and strings, and that strings that are recognised as booleans, as done by #g_key_file_get_boolean, will be of boolean type. not free or destroy any data in this hashtable. a #GHashTable of string keys and #GValue values. Do Sets whether the plugin should be visible in the plugin manager. visibility of the plugin Gets the visibility of the plugin. if not. %TRUE if the plugin should be visible, %FALSE