gtk4/auto/

builder.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{BuilderClosureFlags, BuilderScope, ffi};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// ` tag to
    /// describe a UI bound to a specific widget type. GTK will automatically load
    /// the UI definition when instantiating the type, and bind children and
    /// signal handlers to instance fields and function symbols.
    ///
    /// For more information, see the [[`Widget`][crate::Widget] documentation](class.Widget.html#building-composite-widgets-from-template-xml)
    /// for details.
    ///
    /// ## Properties
    ///
    ///
    /// #### `current-object`
    ///  The object the builder is evaluating for.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `scope`
    ///  The scope the builder is operating in
    ///
    /// Readable | Writable | Construct
    ///
    ///
    /// #### `translation-domain`
    ///  The translation domain used when translating property values that
    /// have been marked as translatable.
    ///
    /// If the translation domain is [`None`], [`Builder`][crate::Builder] uses gettext(),
    /// otherwise g_dgettext().
    ///
    /// Readable | Writable
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GtkBuilder")]
    pub struct Builder(Object<ffi::GtkBuilder, ffi::GtkBuilderClass>);

    match fn {
        type_ => || ffi::gtk_builder_get_type(),
    }
}

impl Builder {
    /// Creates a new empty builder object.
    ///
    /// This function is only useful if you intend to make multiple calls
    /// to [`add_from_file()`][Self::add_from_file()], [`add_from_resource()`][Self::add_from_resource()]
    /// or [`add_from_string()`][Self::add_from_string()] in order to merge multiple UI
    /// descriptions into a single builder.
    ///
    /// # Returns
    ///
    /// a new (empty) [`Builder`][crate::Builder] object
    #[doc(alias = "gtk_builder_new")]
    pub fn new() -> Builder {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::gtk_builder_new()) }
    }

    /// Parses the UI definition at @resource_path.
    ///
    /// If there is an error locating the resource or parsing the
    /// description, then the program will be aborted.
    /// ## `resource_path`
    /// a `GResource` resource path
    ///
    /// # Returns
    ///
    /// a [`Builder`][crate::Builder] containing the described interface
    #[doc(alias = "gtk_builder_new_from_resource")]
    #[doc(alias = "new_from_resource")]
    pub fn from_resource(resource_path: &str) -> Builder {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_builder_new_from_resource(
                resource_path.to_glib_none().0,
            ))
        }
    }

    /// Parses the UI definition in @string.
    ///
    /// If @string is [`None`]-terminated, then @length should be -1.
    /// If @length is not -1, then it is the length of @string.
    ///
    /// If there is an error parsing @string then the program will be
    /// aborted. You should not attempt to parse user interface description
    /// from untrusted sources.
    /// ## `string`
    /// a user interface (XML) description
    /// ## `length`
    /// the length of @string, or -1
    ///
    /// # Returns
    ///
    /// a [`Builder`][crate::Builder] containing the interface described by @string
    #[doc(alias = "gtk_builder_new_from_string")]
    #[doc(alias = "new_from_string")]
    pub fn from_string(string: &str) -> Builder {
        assert_initialized_main_thread!();
        let length = string.len() as _;
        unsafe {
            from_glib_full(ffi::gtk_builder_new_from_string(
                string.to_glib_none().0,
                length,
            ))
        }
    }

    /// Parses a resource file containing a UI definition
    /// and merges it with the current contents of @self.
    ///
    /// This function is useful if you need to call
    /// [`set_current_object()`][Self::set_current_object()] to add user data to
    /// callbacks before loading GtkBuilder UI. Otherwise, you probably
    /// want [`from_resource()`][Self::from_resource()] instead.
    ///
    /// If an error occurs, 0 will be returned and @error will be assigned a
    /// `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_RESOURCE_ERROR`
    /// domain.
    ///
    /// It’s not really reasonable to attempt to handle failures of this
    /// call.  The only reasonable thing to do when an error is detected is
    /// to call g_error().
    /// ## `resource_path`
    /// the path of the resource file to parse
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if an error occurred
    #[doc(alias = "gtk_builder_add_from_resource")]
    pub fn add_from_resource(&self, resource_path: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_add_from_resource(
                self.to_glib_none().0,
                resource_path.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Parses a string containing a UI definition and merges it
    /// with the current contents of @self.
    ///
    /// This function is useful if you need to call
    /// [`set_current_object()`][Self::set_current_object()] to add user data to
    /// callbacks before loading [`Builder`][crate::Builder] UI. Otherwise, you probably
    /// want [`from_string()`][Self::from_string()] instead.
    ///
    /// Upon errors [`false`] will be returned and @error will be assigned a
    /// `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or
    /// `G_VARIANT_PARSE_ERROR` domain.
    ///
    /// It’s not really reasonable to attempt to handle failures of this
    /// call.  The only reasonable thing to do when an error is detected is
    /// to call g_error().
    /// ## `buffer`
    /// the string to parse
    /// ## `length`
    /// the length of @buffer (may be -1 if @buffer is nul-terminated)
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if an error occurred
    #[doc(alias = "gtk_builder_add_from_string")]
    pub fn add_from_string(&self, buffer: &str) -> Result<(), glib::Error> {
        let length = buffer.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_add_from_string(
                self.to_glib_none().0,
                buffer.to_glib_none().0,
                length,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Parses a file containing a UI definition building only the
    /// requested objects and merges them with the current contents
    /// of @self.
    ///
    /// Upon errors, 0 will be returned and @error will be assigned a
    /// `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_FILE_ERROR`
    /// domain.
    ///
    /// If you are adding an object that depends on an object that is not
    /// its child (for instance a [`TreeView`][crate::TreeView] that depends on its
    /// [`TreeModel`][crate::TreeModel]), you have to explicitly list all of them in @object_ids.
    /// ## `filename`
    /// the name of the file to parse
    /// ## `object_ids`
    /// nul-terminated array of objects to build
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if an error occurred
    #[doc(alias = "gtk_builder_add_objects_from_file")]
    pub fn add_objects_from_file(
        &self,
        filename: impl AsRef<std::path::Path>,
        object_ids: &[&str],
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_add_objects_from_file(
                self.to_glib_none().0,
                filename.as_ref().to_glib_none().0,
                object_ids.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Parses a resource file containing a UI definition, building
    /// only the requested objects and merges them with the current
    /// contents of @self.
    ///
    /// Upon errors, 0 will be returned and @error will be assigned a
    /// `GError` from the `GTK_BUILDER_ERROR`, `G_MARKUP_ERROR` or `G_RESOURCE_ERROR`
    /// domain.
    ///
    /// If you are adding an object that depends on an object that is not
    /// its child (for instance a [`TreeView`][crate::TreeView] that depends on its
    /// [`TreeModel`][crate::TreeModel]), you have to explicitly list all of them in @object_ids.
    /// ## `resource_path`
    /// the path of the resource file to parse
    /// ## `object_ids`
    /// nul-terminated array of objects to build
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if an error occurred
    #[doc(alias = "gtk_builder_add_objects_from_resource")]
    pub fn add_objects_from_resource(
        &self,
        resource_path: &str,
        object_ids: &[&str],
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_add_objects_from_resource(
                self.to_glib_none().0,
                resource_path.to_glib_none().0,
                object_ids.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Parses a string containing a UI definition, building only the
    /// requested objects and merges them with the current contents of
    /// @self.
    ///
    /// Upon errors [`false`] will be returned and @error will be assigned a
    /// `GError` from the `GTK_BUILDER_ERROR` or `G_MARKUP_ERROR` domain.
    ///
    /// If you are adding an object that depends on an object that is not
    /// its child (for instance a [`TreeView`][crate::TreeView] that depends on its
    /// [`TreeModel`][crate::TreeModel]), you have to explicitly list all of them in @object_ids.
    /// ## `buffer`
    /// the string to parse
    /// ## `length`
    /// the length of @buffer (may be -1 if @buffer is nul-terminated)
    /// ## `object_ids`
    /// nul-terminated array of objects to build
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] if an error occurred
    #[doc(alias = "gtk_builder_add_objects_from_string")]
    pub fn add_objects_from_string(
        &self,
        buffer: &str,
        object_ids: &[&str],
    ) -> Result<(), glib::Error> {
        let length = buffer.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_add_objects_from_string(
                self.to_glib_none().0,
                buffer.to_glib_none().0,
                length,
                object_ids.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Creates a closure to invoke the function called @function_name.
    ///
    /// This is using the create_closure() implementation of @self's
    /// [`BuilderScope`][crate::BuilderScope].
    ///
    /// If no closure could be created, [`None`] will be returned and @error
    /// will be set.
    /// ## `function_name`
    /// name of the function to look up
    /// ## `flags`
    /// closure creation flags
    /// ## `object`
    /// Object to create the closure with
    ///
    /// # Returns
    ///
    /// A new closure for invoking @function_name
    #[doc(alias = "gtk_builder_create_closure")]
    pub fn create_closure(
        &self,
        function_name: &str,
        flags: BuilderClosureFlags,
        object: Option<&impl IsA<glib::Object>>,
    ) -> Result<Option<glib::Closure>, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::gtk_builder_create_closure(
                self.to_glib_none().0,
                function_name.to_glib_none().0,
                flags.into_glib(),
                object.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_none(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Add @object to the @self object pool so it can be
    /// referenced just like any other object built by builder.
    ///
    /// Only a single object may be added using @name. However,
    /// it is not an error to expose the same object under multiple
    /// names. `gtk_builder_get_object()` may be used to determine
    /// if an object has already been added with @name.
    /// ## `name`
    /// the name of the object exposed to the builder
    /// ## `object`
    /// the object to expose
    #[doc(alias = "gtk_builder_expose_object")]
    pub fn expose_object(&self, name: &str, object: &impl IsA<glib::Object>) {
        unsafe {
            ffi::gtk_builder_expose_object(
                self.to_glib_none().0,
                name.to_glib_none().0,
                object.as_ref().to_glib_none().0,
            );
        }
    }

    /// Main private entry point for building composite components
    /// from template XML.
    ///
    /// Most likely you do not need to call this function in applications as
    /// templates are handled by [`Widget`][crate::Widget].
    /// ## `object`
    /// the object that is being extended
    /// ## `template_type`
    /// the type that the template is for
    /// ## `buffer`
    /// the string to parse
    /// ## `length`
    /// the length of @buffer (may be -1 if @buffer is nul-terminated)
    ///
    /// # Returns
    ///
    /// A positive value on success, 0 if an error occurred
    #[doc(alias = "gtk_builder_extend_with_template")]
    pub fn extend_with_template(
        &self,
        object: &impl IsA<glib::Object>,
        template_type: glib::types::Type,
        buffer: &str,
    ) -> Result<(), glib::Error> {
        let length = buffer.len() as _;
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_extend_with_template(
                self.to_glib_none().0,
                object.as_ref().to_glib_none().0,
                template_type.into_glib(),
                buffer.to_glib_none().0,
                length,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets all objects that have been constructed by @self.
    ///
    /// Note that this function does not increment the reference
    /// counts of the returned objects.
    ///
    /// # Returns
    ///
    /// a
    ///   newly-allocated `GSList` containing all the objects
    ///   constructed by the `GtkBuilder instance`. It should be
    ///   freed by g_slist_free()
    #[doc(alias = "gtk_builder_get_objects")]
    #[doc(alias = "get_objects")]
    pub fn objects(&self) -> Vec<glib::Object> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_builder_get_objects(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets the scope in use that was set via gtk_builder_set_scope().
    ///
    /// # Returns
    ///
    /// the current scope
    #[doc(alias = "gtk_builder_get_scope")]
    #[doc(alias = "get_scope")]
    pub fn scope(&self) -> BuilderScope {
        unsafe { from_glib_none(ffi::gtk_builder_get_scope(self.to_glib_none().0)) }
    }

    /// Gets the translation domain of @self.
    ///
    /// # Returns
    ///
    /// the translation domain
    #[doc(alias = "gtk_builder_get_translation_domain")]
    #[doc(alias = "get_translation_domain")]
    #[doc(alias = "translation-domain")]
    pub fn translation_domain(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_builder_get_translation_domain(
                self.to_glib_none().0,
            ))
        }
    }

    /// Looks up a type by name.
    ///
    /// This is using the virtual function that [`Builder`][crate::Builder] has
    /// for that purpose. This is mainly used when implementing
    /// the [`Buildable`][crate::Buildable] interface on a type.
    /// ## `type_name`
    /// type name to lookup
    ///
    /// # Returns
    ///
    /// the `GType` found for @type_name or `G_TYPE_INVALID`
    ///   if no type was found
    #[doc(alias = "gtk_builder_get_type_from_name")]
    #[doc(alias = "get_type_from_name")]
    pub fn type_from_name(&self, type_name: &str) -> glib::types::Type {
        unsafe {
            from_glib(ffi::gtk_builder_get_type_from_name(
                self.to_glib_none().0,
                type_name.to_glib_none().0,
            ))
        }
    }

    /// Sets the current object for the @self.
    ///
    /// The current object can be thought of as the `this` object that the
    /// builder is working for and will often be used as the default object
    /// when an object is optional.
    ///
    /// `Gtk::Widget::init_template()` for example will set the current
    /// object to the widget the template is inited for. For functions like
    /// [`from_resource()`][Self::from_resource()], the current object will be [`None`].
    /// ## `current_object`
    /// the new current object
    #[doc(alias = "gtk_builder_set_current_object")]
    #[doc(alias = "current-object")]
    pub fn set_current_object(&self, current_object: Option<&impl IsA<glib::Object>>) {
        unsafe {
            ffi::gtk_builder_set_current_object(
                self.to_glib_none().0,
                current_object.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the scope the builder should operate in.
    ///
    /// If @scope is [`None`], a new `Gtk::BuilderCScope` will be created.
    /// ## `scope`
    /// the scope to use
    #[doc(alias = "gtk_builder_set_scope")]
    #[doc(alias = "scope")]
    pub fn set_scope(&self, scope: Option<&impl IsA<BuilderScope>>) {
        unsafe {
            ffi::gtk_builder_set_scope(
                self.to_glib_none().0,
                scope.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the translation domain of @self.
    /// ## `domain`
    /// the translation domain
    #[doc(alias = "gtk_builder_set_translation_domain")]
    #[doc(alias = "translation-domain")]
    pub fn set_translation_domain(&self, domain: Option<&str>) {
        unsafe {
            ffi::gtk_builder_set_translation_domain(self.to_glib_none().0, domain.to_glib_none().0);
        }
    }

    /// Demarshals a value from a string.
    ///
    /// This function calls g_value_init() on the @value argument,
    /// so it need not be initialised beforehand.
    ///
    /// Can handle char, uchar, boolean, int, uint, long,
    /// ulong, enum, flags, float, double, string, [`gdk::RGBA`][crate::gdk::RGBA] and
    /// [`Adjustment`][crate::Adjustment] type values.
    ///
    /// Upon errors [`false`] will be returned and @error will be
    /// assigned a `GError` from the `GTK_BUILDER_ERROR` domain.
    /// ## `pspec`
    /// the `GParamSpec` for the property
    /// ## `string`
    /// the string representation of the value
    ///
    /// # Returns
    ///
    /// [`true`] on success
    ///
    /// ## `value`
    /// the `GValue` to store the result in
    #[doc(alias = "gtk_builder_value_from_string")]
    pub fn value_from_string(
        &self,
        pspec: impl AsRef<glib::ParamSpec>,
        string: &str,
    ) -> Result<glib::Value, glib::Error> {
        unsafe {
            let mut value = glib::Value::uninitialized();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_value_from_string(
                self.to_glib_none().0,
                pspec.as_ref().to_glib_none().0,
                string.to_glib_none().0,
                value.to_glib_none_mut().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(value)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Demarshals a value from a string.
    ///
    /// Unlike [`value_from_string()`][Self::value_from_string()], this function
    /// takes a `GType` instead of `GParamSpec`.
    ///
    /// Calls g_value_init() on the @value argument, so it
    /// need not be initialised beforehand.
    ///
    /// Upon errors [`false`] will be returned and @error will be
    /// assigned a `GError` from the `GTK_BUILDER_ERROR` domain.
    /// ## `type_`
    /// the `GType` of the value
    /// ## `string`
    /// the string representation of the value
    ///
    /// # Returns
    ///
    /// [`true`] on success
    ///
    /// ## `value`
    /// the `GValue` to store the result in
    #[doc(alias = "gtk_builder_value_from_string_type")]
    pub fn value_from_string_type(
        &self,
        type_: glib::types::Type,
        string: &str,
    ) -> Result<glib::Value, glib::Error> {
        unsafe {
            let mut value = glib::Value::uninitialized();
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_builder_value_from_string_type(
                self.to_glib_none().0,
                type_.into_glib(),
                string.to_glib_none().0,
                value.to_glib_none_mut().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(value)
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    #[doc(alias = "current-object")]
    pub fn connect_current_object_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_current_object_trampoline<F: Fn(&Builder) + 'static>(
            this: *mut ffi::GtkBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::current-object".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_current_object_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "scope")]
    pub fn connect_scope_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_scope_trampoline<F: Fn(&Builder) + 'static>(
            this: *mut ffi::GtkBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::scope".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_scope_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "translation-domain")]
    pub fn connect_translation_domain_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_translation_domain_trampoline<F: Fn(&Builder) + 'static>(
            this: *mut ffi::GtkBuilder,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(&from_glib_borrow(this))
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::translation-domain".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_translation_domain_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for Builder {
    fn default() -> Self {
        Self::new()
    }
}