Package ch.bailu.gtk.gio

Class IOModule

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gobject.TypeModule
ch.bailu.gtk.gio.IOModule
All Implemented Interfaces:
PointerInterface
public class IOModule extends TypeModule
Provides an interface and default functions for loading and unloading
modules. This is used internally to make GIO extensible, but can also
be used by others to implement module loading.

https://docs.gtk.org/gio/class.IOModule.html

  • Constructor Details

    • IOModule

      public IOModule(PointerContainer pointer)

    • IOModule

      public IOModule(@Nonnull Str filename)
      Creates a new GIOModule that will load the specific
      shared library when in use.
      Parameters:
      filename - filename of the shared library module.

    • IOModule

      public IOModule(String filename)
      Creates a new GIOModule that will load the specific
      shared library when in use.
      Parameters:
      filename - filename of the shared library module.

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • load

      public void load()
      Required API for GIO modules to implement.

      This function is run after the module has been loaded into GIO,
      to initialize the module. Typically, this function will call
      g_io_extension_point_implement().

      Since 2.56, this function should be named `g_io_<modulename>_load`, where
      `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and
      everything after the first dot removed, and with `-` replaced with `_`
      throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`.
      Using the new symbol names avoids name clashes when building modules
      statically. The old symbol names continue to be supported, but cannot be used
      for static builds.

    • unload

      public void unload()
      Required API for GIO modules to implement.

      This function is run when the module is being unloaded from GIO,
      to finalize the module.

      Since 2.56, this function should be named `g_io_<modulename>_unload`, where
      `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and
      everything after the first dot removed, and with `-` replaced with `_`
      throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`.
      Using the new symbol names avoids name clashes when building modules
      statically. The old symbol names continue to be supported, but cannot be used
      for static builds.

    • query

      public static Strs query()
      Optional API for GIO modules to implement.

      Should return a list of all the extension points that may be
      implemented in this module.

      This method will not be called in normal use, however it may be
      called when probing existing modules and recording which extension
      points that this model is used for. This means we won't have to
      load and initialize this module unless its needed.

      If this function is not implemented by the module the module will
      always be loaded, initialized and then unloaded on application
      startup so that it can register its extension points during init.

      Note that a module need not actually implement all the extension
      points that g_io_module_query() returns, since the exact list of
      extension may depend on runtime issues. However all extension
      points actually implemented must be returned by g_io_module_query()
      (if defined).

      When installing a module that implements g_io_module_query() you must
      run gio-querymodules in order to build the cache files required for
      lazy loading.

      Since 2.56, this function should be named `g_io_<modulename>_query`, where
      `modulename` is the plugin’s filename with the `lib` or `libgio` prefix and
      everything after the first dot removed, and with `-` replaced with `_`
      throughout. For example, `libgiognutls-helper.so` becomes `gnutls_helper`.
      Using the new symbol names avoids name clashes when building modules
      statically. The old symbol names continue to be supported, but cannot be used
      for static builds.
      Returns:
      A %NULL-terminated array of strings, listing the supported extension points of the module. The array must be suitable for freeing with g_strfreev().

    • asTypePlugin

      public TypePlugin asTypePlugin()
      Implements interface TypePlugin. Call this to get access to interface functions.
      Overrides:
      asTypePlugin in class TypeModule
      Returns:
      TypePlugin

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()