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

use crate::Accessible;
use crate::AccessibleProperty;
use crate::AccessibleRelation;
use crate::AccessibleRole;
use crate::AccessibleState;
use crate::DebugFlags;
use crate::PageSetup;
use crate::PrintSettings;
#[cfg(any(target_os = "linux", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(target_os = "linux")))]
use crate::Printer;
use crate::StyleContext;
use crate::TextDirection;
use crate::TreeModel;
use crate::TreePath;
use crate::Widget;
use crate::Window;
use glib::object::IsA;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::mem;
use std::ptr;

/// Gets the modifier mask.
///
/// The modifier mask determines which modifiers are considered significant
/// for keyboard accelerators. This includes all keyboard modifiers except
/// for [`gdk::ModifierType::LOCK_MASK`][crate::gdk::ModifierType::LOCK_MASK].
///
/// # Returns
///
/// the modifier mask for accelerators
#[doc(alias = "gtk_accelerator_get_default_mod_mask")]
pub fn accelerator_get_default_mod_mask() -> gdk::ModifierType {
    assert_initialized_main_thread!();
    unsafe { from_glib(ffi::gtk_accelerator_get_default_mod_mask()) }
}

/// Checks that the GTK library in use is compatible with the
/// given version.
///
/// Generally you would pass in the constants `GTK_MAJOR_VERSION`,
/// `GTK_MINOR_VERSION`, `GTK_MICRO_VERSION` as the three arguments
/// to this function; that produces a check that the library in
/// use is compatible with the version of GTK the application or
/// module was compiled against.
///
/// Compatibility is defined by two things: first the version
/// of the running library is newer than the version
/// @required_major.required_minor.@required_micro. Second
/// the running library must be binary compatible with the
/// version @required_major.required_minor.@required_micro
/// (same major version.)
///
/// This function is primarily for GTK modules; the module
/// can call this function to check that it wasn’t loaded
/// into an incompatible version of GTK. However, such a
/// check isn’t completely reliable, since the module may be
/// linked against an old version of GTK and calling the
/// old version of gtk_check_version(), but still get loaded
/// into an application using a newer version of GTK.
/// ## `required_major`
/// the required major version
/// ## `required_minor`
/// the required minor version
/// ## `required_micro`
/// the required micro version
///
/// # Returns
///
/// [`None`] if the GTK library is compatible with the
///   given version, or a string describing the version mismatch.
///   The returned string is owned by GTK and should not be modified
///   or freed.
#[doc(alias = "gtk_check_version")]
pub fn check_version(
    required_major: u32,
    required_minor: u32,
    required_micro: u32,
) -> Option<glib::GString> {
    skip_assert_initialized!();
    unsafe {
        from_glib_none(ffi::gtk_check_version(
            required_major,
            required_minor,
            required_micro,
        ))
    }
}

/// Prevents `gtk_init` and `gtk_init_check` from automatically calling
/// `setlocale (LC_ALL, "")`.
///
/// You would want to use this function if you wanted to set the locale for
/// your program to something other than the user’s locale, or if
/// you wanted to set different values for different locale categories.
///
/// Most programs should not need to call this function.
#[doc(alias = "gtk_disable_setlocale")]
pub fn disable_setlocale() {
    assert_not_initialized!();
    unsafe {
        ffi::gtk_disable_setlocale();
    }
}

//#[doc(alias = "gtk_distribute_natural_allocation")]
//pub fn distribute_natural_allocation(extra_space: i32, sizes: /*Ignored*/&[RequestedSize]) -> i32 {
//    unsafe { TODO: call ffi:gtk_distribute_natural_allocation() }
//}

/// Calls a function for all [`Printer`][crate::Printer]s.
///
/// If @func returns [`true`], the enumeration is stopped.
/// ## `func`
/// a function to call for each printer
/// ## `wait`
/// if [`true`], wait in a recursive mainloop until
///    all printers are enumerated; otherwise return early
#[cfg(any(target_os = "linux", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(target_os = "linux")))]
#[doc(alias = "gtk_enumerate_printers")]
pub fn enumerate_printers<P: Fn(&Printer) -> bool + Send + Sync + 'static>(func: P, wait: bool) {
    assert_initialized_main_thread!();
    let func_data: Box_<P> = Box_::new(func);
    unsafe extern "C" fn func_func<P: Fn(&Printer) -> bool + Send + Sync + 'static>(
        printer: *mut ffi::GtkPrinter,
        data: glib::ffi::gpointer,
    ) -> glib::ffi::gboolean {
        let printer = from_glib_borrow(printer);
        let callback: &P = &*(data as *mut _);
        let res = (*callback)(&printer);
        res.into_glib()
    }
    let func = Some(func_func::<P> as _);
    unsafe extern "C" fn destroy_func<P: Fn(&Printer) -> bool + Send + Sync + 'static>(
        data: glib::ffi::gpointer,
    ) {
        let _callback: Box_<P> = Box_::from_raw(data as *mut _);
    }
    let destroy_call2 = Some(destroy_func::<P> as _);
    let super_callback0: Box_<P> = func_data;
    unsafe {
        ffi::gtk_enumerate_printers(
            func,
            Box_::into_raw(super_callback0) as *mut _,
            destroy_call2,
            wait.into_glib(),
        );
    }
}

/// Returns the binary age as passed to `libtool`.
///
/// If `libtool` means nothing to you, don't worry about it.
///
/// # Returns
///
/// the binary age of the GTK library
#[doc(alias = "gtk_get_binary_age")]
#[doc(alias = "get_binary_age")]
pub fn binary_age() -> u32 {
    skip_assert_initialized!();
    unsafe { ffi::gtk_get_binary_age() }
}

/// Returns the GTK debug flags that are currently active.
///
/// This function is intended for GTK modules that want
/// to adjust their debug output based on GTK debug flags.
///
/// # Returns
///
/// the GTK debug flags.
#[doc(alias = "gtk_get_debug_flags")]
#[doc(alias = "get_debug_flags")]
pub fn debug_flags() -> DebugFlags {
    assert_initialized_main_thread!();
    unsafe { from_glib(ffi::gtk_get_debug_flags()) }
}

/// Returns the [`pango::Language`][crate::pango::Language] for the default language
/// currently in effect.
///
/// Note that this can change over the life of an
/// application.
///
/// The default language is derived from the current
/// locale. It determines, for example, whether GTK uses
/// the right-to-left or left-to-right text direction.
///
/// This function is equivalent to
/// [`pango::Language::default()`][crate::pango::Language::default()].
/// See that function for details.
///
/// # Returns
///
/// the default language as a
///   [`pango::Language`][crate::pango::Language]
#[doc(alias = "gtk_get_default_language")]
#[doc(alias = "get_default_language")]
pub fn default_language() -> pango::Language {
    assert_initialized_main_thread!();
    unsafe { from_glib_none(ffi::gtk_get_default_language()) }
}

/// Returns the interface age as passed to `libtool`.
///
/// If `libtool` means nothing to you, don't worry about it.
///
/// # Returns
///
/// the interface age of the GTK library
#[doc(alias = "gtk_get_interface_age")]
#[doc(alias = "get_interface_age")]
pub fn interface_age() -> u32 {
    skip_assert_initialized!();
    unsafe { ffi::gtk_get_interface_age() }
}

/// Get the direction of the current locale. This is the expected
/// reading direction for text and UI.
///
/// This function depends on the current locale being set with
/// setlocale() and will default to setting the [`TextDirection::Ltr`][crate::TextDirection::Ltr]
/// direction otherwise. [`TextDirection::None`][crate::TextDirection::None] will never be returned.
///
/// GTK sets the default text direction according to the locale
/// during gtk_init(), and you should normally use
/// gtk_widget_get_direction() or gtk_widget_get_default_direction()
/// to obtain the current direction.
///
/// This function is only needed rare cases when the locale is
/// changed after GTK has already been initialized. In this case,
/// you can use it to update the default text direction as follows:
///
///
///
/// **⚠️ The following code is in C ⚠️**
///
/// ```C
/// #include <locale.h>
///
/// static void
/// update_locale (const char *new_locale)
/// {
///   setlocale (LC_ALL, new_locale);
///   GtkTextDirection direction = gtk_get_locale_direction ();
///   gtk_widget_set_default_direction (direction);
/// }
/// ```
///
/// # Returns
///
/// the [`TextDirection`][crate::TextDirection] of the current locale
#[doc(alias = "gtk_get_locale_direction")]
#[doc(alias = "get_locale_direction")]
pub fn locale_direction() -> TextDirection {
    assert_initialized_main_thread!();
    unsafe { from_glib(ffi::gtk_get_locale_direction()) }
}

/// Returns the major version number of the GTK library.
///
/// For example, in GTK version 3.1.5 this is 3.
///
/// This function is in the library, so it represents the GTK library
/// your code is running against. Contrast with the `GTK_MAJOR_VERSION`
/// macro, which represents the major version of the GTK headers you
/// have included when compiling your code.
///
/// # Returns
///
/// the major version number of the GTK library
#[doc(alias = "gtk_get_major_version")]
#[doc(alias = "get_major_version")]
pub fn major_version() -> u32 {
    skip_assert_initialized!();
    unsafe { ffi::gtk_get_major_version() }
}

/// Returns the micro version number of the GTK library.
///
/// For example, in GTK version 3.1.5 this is 5.
///
/// This function is in the library, so it represents the GTK library
/// your code is are running against. Contrast with the
/// `GTK_MICRO_VERSION` macro, which represents the micro version of the
/// GTK headers you have included when compiling your code.
///
/// # Returns
///
/// the micro version number of the GTK library
#[doc(alias = "gtk_get_micro_version")]
#[doc(alias = "get_micro_version")]
pub fn micro_version() -> u32 {
    skip_assert_initialized!();
    unsafe { ffi::gtk_get_micro_version() }
}

/// Returns the minor version number of the GTK library.
///
/// For example, in GTK version 3.1.5 this is 1.
///
/// This function is in the library, so it represents the GTK library
/// your code is are running against. Contrast with the
/// `GTK_MINOR_VERSION` macro, which represents the minor version of the
/// GTK headers you have included when compiling your code.
///
/// # Returns
///
/// the minor version number of the GTK library
#[doc(alias = "gtk_get_minor_version")]
#[doc(alias = "get_minor_version")]
pub fn minor_version() -> u32 {
    skip_assert_initialized!();
    unsafe { ffi::gtk_get_minor_version() }
}

/// Converts a color from HSV space to RGB.
///
/// Input values must be in the [0.0, 1.0] range;
/// output values will be in the same range.
/// ## `h`
/// Hue
/// ## `s`
/// Saturation
/// ## `v`
/// Value
///
/// # Returns
///
///
/// ## `r`
/// Return value for the red component
///
/// ## `g`
/// Return value for the green component
///
/// ## `b`
/// Return value for the blue component
#[doc(alias = "gtk_hsv_to_rgb")]
pub fn hsv_to_rgb(h: f32, s: f32, v: f32) -> (f32, f32, f32) {
    assert_initialized_main_thread!();
    unsafe {
        let mut r = mem::MaybeUninit::uninit();
        let mut g = mem::MaybeUninit::uninit();
        let mut b = mem::MaybeUninit::uninit();
        ffi::gtk_hsv_to_rgb(h, s, v, r.as_mut_ptr(), g.as_mut_ptr(), b.as_mut_ptr());
        (r.assume_init(), g.assume_init(), b.assume_init())
    }
}

/// Runs a page setup dialog, letting the user modify the values from
/// @page_setup. If the user cancels the dialog, the returned [`PageSetup`][crate::PageSetup]
/// is identical to the passed in @page_setup, otherwise it contains the
/// modifications done in the dialog.
///
/// Note that this function may use a recursive mainloop to show the page
/// setup dialog. See gtk_print_run_page_setup_dialog_async() if this is
/// a problem.
/// ## `parent`
/// transient parent
/// ## `page_setup`
/// an existing [`PageSetup`][crate::PageSetup]
/// ## `settings`
/// a [`PrintSettings`][crate::PrintSettings]
///
/// # Returns
///
/// a new [`PageSetup`][crate::PageSetup]
#[doc(alias = "gtk_print_run_page_setup_dialog")]
pub fn print_run_page_setup_dialog(
    parent: Option<&impl IsA<Window>>,
    page_setup: Option<&PageSetup>,
    settings: &PrintSettings,
) -> PageSetup {
    skip_assert_initialized!();
    unsafe {
        from_glib_full(ffi::gtk_print_run_page_setup_dialog(
            parent.map(|p| p.as_ref()).to_glib_none().0,
            page_setup.to_glib_none().0,
            settings.to_glib_none().0,
        ))
    }
}

/// Runs a page setup dialog, letting the user modify the values from @page_setup.
///
/// In contrast to gtk_print_run_page_setup_dialog(), this function  returns after
/// showing the page setup dialog on platforms that support this, and calls @done_cb
/// from a signal handler for the ::response signal of the dialog.
/// ## `parent`
/// transient parent
/// ## `page_setup`
/// an existing [`PageSetup`][crate::PageSetup]
/// ## `settings`
/// a [`PrintSettings`][crate::PrintSettings]
/// ## `done_cb`
/// a function to call when the user saves
///    the modified page setup
#[doc(alias = "gtk_print_run_page_setup_dialog_async")]
pub fn print_run_page_setup_dialog_async<P: FnOnce(&PageSetup) + Send + Sync + 'static>(
    parent: Option<&impl IsA<Window>>,
    page_setup: Option<&PageSetup>,
    settings: &PrintSettings,
    done_cb: P,
) {
    skip_assert_initialized!();
    let done_cb_data: Box_<P> = Box_::new(done_cb);
    unsafe extern "C" fn done_cb_func<P: FnOnce(&PageSetup) + Send + Sync + 'static>(
        page_setup: *mut ffi::GtkPageSetup,
        data: glib::ffi::gpointer,
    ) {
        let page_setup = from_glib_borrow(page_setup);
        let callback: Box_<P> = Box_::from_raw(data as *mut _);
        (*callback)(&page_setup);
    }
    let done_cb = Some(done_cb_func::<P> as _);
    let super_callback0: Box_<P> = done_cb_data;
    unsafe {
        ffi::gtk_print_run_page_setup_dialog_async(
            parent.map(|p| p.as_ref()).to_glib_none().0,
            page_setup.to_glib_none().0,
            settings.to_glib_none().0,
            done_cb,
            Box_::into_raw(super_callback0) as *mut _,
        );
    }
}

/// Renders an activity indicator (such as in [`Spinner`][crate::Spinner]).
/// The state [`StateFlags::CHECKED`][crate::StateFlags::CHECKED] determines whether there is
/// activity going on.
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_activity")]
pub fn render_activity(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_activity(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders an arrow pointing to @angle.
///
/// Typical arrow rendering at 0, 1⁄2 π;, π; and 3⁄2 π:
///
/// ![](arrows.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `angle`
/// arrow angle from 0 to 2 * `G_PI`, being 0 the arrow pointing to the north
/// ## `x`
/// X origin of the render area
/// ## `y`
/// Y origin of the render area
/// ## `size`
/// square side for render area
#[doc(alias = "gtk_render_arrow")]
pub fn render_arrow(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    angle: f64,
    x: f64,
    y: f64,
    size: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_arrow(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            angle,
            x,
            y,
            size,
        );
    }
}

/// Renders the background of an element.
///
/// Typical background rendering, showing the effect of
/// `background-image`, `border-width` and `border-radius`:
///
/// ![](background.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_background")]
pub fn render_background(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_background(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders a checkmark (as in a [`CheckButton`][crate::CheckButton]).
///
/// The [`StateFlags::CHECKED`][crate::StateFlags::CHECKED] state determines whether the check is
/// on or off, and [`StateFlags::INCONSISTENT`][crate::StateFlags::INCONSISTENT] determines whether it
/// should be marked as undefined.
///
/// Typical checkmark rendering:
///
/// ![](checks.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_check")]
pub fn render_check(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_check(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders an expander (as used in [`TreeView`][crate::TreeView] and [`Expander`][crate::Expander]) in the area
/// defined by @x, @y, @width, @height. The state [`StateFlags::CHECKED`][crate::StateFlags::CHECKED]
/// determines whether the expander is collapsed or expanded.
///
/// Typical expander rendering:
///
/// ![](expanders.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_expander")]
pub fn render_expander(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_expander(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders a focus indicator on the rectangle determined by @x, @y, @width, @height.
///
/// Typical focus rendering:
///
/// ![](focus.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_focus")]
pub fn render_focus(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_focus(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders a frame around the rectangle defined by @x, @y, @width, @height.
///
/// Examples of frame rendering, showing the effect of `border-image`,
/// `border-color`, `border-width`, `border-radius` and junctions:
///
/// ![](frames.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_frame")]
pub fn render_frame(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_frame(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders a handle (as in [`Paned`][crate::Paned] and [`Window`][crate::Window]’s resize grip),
/// in the rectangle determined by @x, @y, @width, @height.
///
/// Handles rendered for the paned and grip classes:
///
/// ![](handles.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_handle")]
pub fn render_handle(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_handle(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Renders the icon in @texture at the specified @x and @y coordinates.
///
/// This function will render the icon in @texture at exactly its size,
/// regardless of scaling factors, which may not be appropriate when
/// drawing on displays with high pixel densities.
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `texture`
/// a [`gdk::Texture`][crate::gdk::Texture] containing the icon to draw
/// ## `x`
/// X position for the @texture
/// ## `y`
/// Y position for the @texture
#[doc(alias = "gtk_render_icon")]
pub fn render_icon(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    texture: &impl IsA<gdk::Texture>,
    x: f64,
    y: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_icon(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            texture.as_ref().to_glib_none().0,
            x,
            y,
        );
    }
}

/// Renders @layout on the coordinates @x, @y
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin
/// ## `y`
/// Y origin
/// ## `layout`
/// the [`pango::Layout`][crate::pango::Layout] to render
#[doc(alias = "gtk_render_layout")]
pub fn render_layout(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    layout: &pango::Layout,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_layout(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            layout.to_glib_none().0,
        );
    }
}

/// Renders a line from (x0, y0) to (x1, y1).
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x0`
/// X coordinate for the origin of the line
/// ## `y0`
/// Y coordinate for the origin of the line
/// ## `x1`
/// X coordinate for the end of the line
/// ## `y1`
/// Y coordinate for the end of the line
#[doc(alias = "gtk_render_line")]
pub fn render_line(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x0: f64,
    y0: f64,
    x1: f64,
    y1: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_line(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x0,
            y0,
            x1,
            y1,
        );
    }
}

/// Renders an option mark (as in a radio button), the [`StateFlags::CHECKED`][crate::StateFlags::CHECKED]
/// state will determine whether the option is on or off, and
/// [`StateFlags::INCONSISTENT`][crate::StateFlags::INCONSISTENT] whether it should be marked as undefined.
///
/// Typical option mark rendering:
///
/// ![](options.png)
/// ## `context`
/// a [`StyleContext`][crate::StyleContext]
/// ## `cr`
/// a [`cairo::Context`][crate::cairo::Context]
/// ## `x`
/// X origin of the rectangle
/// ## `y`
/// Y origin of the rectangle
/// ## `width`
/// rectangle width
/// ## `height`
/// rectangle height
#[doc(alias = "gtk_render_option")]
pub fn render_option(
    context: &impl IsA<StyleContext>,
    cr: &cairo::Context,
    x: f64,
    y: f64,
    width: f64,
    height: f64,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_render_option(
            context.as_ref().to_glib_none().0,
            mut_override(cr.to_glib_none().0),
            x,
            y,
            width,
            height,
        );
    }
}

/// Converts a color from RGB space to HSV.
///
/// Input values must be in the [0.0, 1.0] range;
/// output values will be in the same range.
/// ## `r`
/// Red
/// ## `g`
/// Green
/// ## `b`
/// Blue
///
/// # Returns
///
///
/// ## `h`
/// Return value for the hue component
///
/// ## `s`
/// Return value for the saturation component
///
/// ## `v`
/// Return value for the value component
#[doc(alias = "gtk_rgb_to_hsv")]
pub fn rgb_to_hsv(r: f32, g: f32, b: f32) -> (f32, f32, f32) {
    assert_initialized_main_thread!();
    unsafe {
        let mut h = mem::MaybeUninit::uninit();
        let mut s = mem::MaybeUninit::uninit();
        let mut v = mem::MaybeUninit::uninit();
        ffi::gtk_rgb_to_hsv(r, g, b, h.as_mut_ptr(), s.as_mut_ptr(), v.as_mut_ptr());
        (h.assume_init(), s.assume_init(), v.assume_init())
    }
}

/// Sets the GTK debug flags.
/// ## `flags`
/// the debug flags to set
#[doc(alias = "gtk_set_debug_flags")]
pub fn set_debug_flags(flags: DebugFlags) {
    assert_initialized_main_thread!();
    unsafe {
        ffi::gtk_set_debug_flags(flags.into_glib());
    }
}

/// This function launches the default application for showing
/// a given uri, or shows an error dialog if that fails.
/// ## `parent`
/// parent window
/// ## `uri`
/// the uri to show
/// ## `timestamp`
/// timestamp from the event that triggered this call, or `GDK_CURRENT_TIME`
#[doc(alias = "gtk_show_uri")]
pub fn show_uri(parent: Option<&impl IsA<Window>>, uri: &str, timestamp: u32) {
    assert_initialized_main_thread!();
    unsafe {
        ffi::gtk_show_uri(
            parent.map(|p| p.as_ref()).to_glib_none().0,
            uri.to_glib_none().0,
            timestamp,
        );
    }
}

#[doc(alias = "gtk_test_accessible_assertion_message_role")]
pub fn test_accessible_assertion_message_role(
    domain: &str,
    file: &str,
    line: i32,
    func: &str,
    expr: &str,
    accessible: &impl IsA<Accessible>,
    expected_role: AccessibleRole,
    actual_role: AccessibleRole,
) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_test_accessible_assertion_message_role(
            domain.to_glib_none().0,
            file.to_glib_none().0,
            line,
            func.to_glib_none().0,
            expr.to_glib_none().0,
            accessible.as_ref().to_glib_none().0,
            expected_role.into_glib(),
            actual_role.into_glib(),
        );
    }
}

/// Checks whether the [`Accessible`][crate::Accessible] has @property set.
/// ## `accessible`
/// a [`Accessible`][crate::Accessible]
/// ## `property`
/// a [`AccessibleProperty`][crate::AccessibleProperty]
///
/// # Returns
///
/// [`true`] if the @property is set in the @accessible
#[doc(alias = "gtk_test_accessible_has_property")]
pub fn test_accessible_has_property(
    accessible: &impl IsA<Accessible>,
    property: AccessibleProperty,
) -> bool {
    skip_assert_initialized!();
    unsafe {
        from_glib(ffi::gtk_test_accessible_has_property(
            accessible.as_ref().to_glib_none().0,
            property.into_glib(),
        ))
    }
}

/// Checks whether the [`Accessible`][crate::Accessible] has @relation set.
/// ## `accessible`
/// a [`Accessible`][crate::Accessible]
/// ## `relation`
/// a [`AccessibleRelation`][crate::AccessibleRelation]
///
/// # Returns
///
/// [`true`] if the @relation is set in the @accessible
#[doc(alias = "gtk_test_accessible_has_relation")]
pub fn test_accessible_has_relation(
    accessible: &impl IsA<Accessible>,
    relation: AccessibleRelation,
) -> bool {
    skip_assert_initialized!();
    unsafe {
        from_glib(ffi::gtk_test_accessible_has_relation(
            accessible.as_ref().to_glib_none().0,
            relation.into_glib(),
        ))
    }
}

/// Checks whether the `GtkAccessible:accessible-role` of the accessible
/// is @role.
/// ## `accessible`
/// a [`Accessible`][crate::Accessible]
/// ## `role`
/// a [`AccessibleRole`][crate::AccessibleRole]
///
/// # Returns
///
/// [`true`] if the role matches
#[doc(alias = "gtk_test_accessible_has_role")]
pub fn test_accessible_has_role(accessible: &impl IsA<Accessible>, role: AccessibleRole) -> bool {
    skip_assert_initialized!();
    unsafe {
        from_glib(ffi::gtk_test_accessible_has_role(
            accessible.as_ref().to_glib_none().0,
            role.into_glib(),
        ))
    }
}

/// Checks whether the [`Accessible`][crate::Accessible] has @state set.
/// ## `accessible`
/// a [`Accessible`][crate::Accessible]
/// ## `state`
/// a [`AccessibleState`][crate::AccessibleState]
///
/// # Returns
///
/// [`true`] if the @state is set in the @accessible
#[doc(alias = "gtk_test_accessible_has_state")]
pub fn test_accessible_has_state(
    accessible: &impl IsA<Accessible>,
    state: AccessibleState,
) -> bool {
    skip_assert_initialized!();
    unsafe {
        from_glib(ffi::gtk_test_accessible_has_state(
            accessible.as_ref().to_glib_none().0,
            state.into_glib(),
        ))
    }
}

//#[doc(alias = "gtk_test_init")]
//pub fn test_init(argvp: /*Unimplemented*/Vec<glib::GString>, : /*Unknown conversion*//*Unimplemented*/Basic: VarArgs) {
//    unsafe { TODO: call ffi:gtk_test_init() }
//}

/// Force registration of all core GTK object types.
///
/// This allowes to refer to any of those object types via
/// g_type_from_name() after calling this function.
#[doc(alias = "gtk_test_register_all_types")]
pub fn test_register_all_types() {
    assert_initialized_main_thread!();
    unsafe {
        ffi::gtk_test_register_all_types();
    }
}

/// Enters the main loop and waits for @widget to be “drawn”.
///
/// In this context that means it waits for the frame clock of
/// @widget to have run a full styling, layout and drawing cycle.
///
/// This function is intended to be used for syncing with actions that
/// depend on @widget relayouting or on interaction with the display
/// server.
/// ## `widget`
/// the widget to wait for
#[doc(alias = "gtk_test_widget_wait_for_draw")]
pub fn test_widget_wait_for_draw(widget: &impl IsA<Widget>) {
    skip_assert_initialized!();
    unsafe {
        ffi::gtk_test_widget_wait_for_draw(widget.as_ref().to_glib_none().0);
    }
}

/// Creates a content provider for dragging @path from @tree_model.
/// ## `tree_model`
/// a [`TreeModel`][crate::TreeModel]
/// ## `path`
/// a row in @tree_model
///
/// # Returns
///
/// a new [`gdk::ContentProvider`][crate::gdk::ContentProvider]
#[doc(alias = "gtk_tree_create_row_drag_content")]
pub fn tree_create_row_drag_content(
    tree_model: &impl IsA<TreeModel>,
    path: &TreePath,
) -> gdk::ContentProvider {
    skip_assert_initialized!();
    unsafe {
        from_glib_full(ffi::gtk_tree_create_row_drag_content(
            tree_model.as_ref().to_glib_none().0,
            mut_override(path.to_glib_none().0),
        ))
    }
}

/// Obtains a @tree_model and @path from value of target type
/// `GTK_TYPE_TREE_ROW_DATA`.
///
/// The returned path must be freed with gtk_tree_path_free().
/// ## `value`
/// a `GValue`
///
/// # Returns
///
/// [`true`] if @selection_data had target type `GTK_TYPE_TREE_ROW_DATA`
///  is otherwise valid
///
/// ## `tree_model`
/// a [`TreeModel`][crate::TreeModel]
///
/// ## `path`
/// row in @tree_model
#[doc(alias = "gtk_tree_get_row_drag_data")]
pub fn tree_get_row_drag_data(
    value: &glib::Value,
) -> Option<(Option<TreeModel>, Option<TreePath>)> {
    assert_initialized_main_thread!();
    unsafe {
        let mut tree_model = ptr::null_mut();
        let mut path = ptr::null_mut();
        let ret = from_glib(ffi::gtk_tree_get_row_drag_data(
            value.to_glib_none().0,
            &mut tree_model,
            &mut path,
        ));
        if ret {
            Some((from_glib_none(tree_model), from_glib_full(path)))
        } else {
            None
        }
    }
}