// 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::translate::*;

crate::wrapper! {
    /// The `GMainContext` struct is an opaque data
    /// type representing a set of sources to be handled in a main loop.
    #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
    pub struct MainContext(Shared<ffi::GMainContext>);

    match fn {
        ref => |ptr| ffi::g_main_context_ref(ptr),
        unref => |ptr| ffi::g_main_context_unref(ptr),
        type_ => || ffi::g_main_context_get_type(),
    }
}

impl MainContext {
    /// Creates a new [`MainContext`][crate::MainContext] structure.
    ///
    /// # Returns
    ///
    /// the new [`MainContext`][crate::MainContext]
    #[doc(alias = "g_main_context_new")]
    pub fn new() -> MainContext {
        unsafe { from_glib_full(ffi::g_main_context_new()) }
    }

    //#[doc(alias = "g_main_context_add_poll")]
    //pub fn add_poll(&self, fd: /*Ignored*/&mut PollFD, priority: i32) {
    //    unsafe { TODO: call ffi:g_main_context_add_poll() }
    //}

    //#[doc(alias = "g_main_context_check")]
    //pub fn check(&self, max_priority: i32, fds: /*Ignored*/&[&PollFD]) -> bool {
    //    unsafe { TODO: call ffi:g_main_context_check() }
    //}

    /// Dispatches all pending sources.
    ///
    /// You must have successfully acquired the context with
    /// [`acquire()`][Self::acquire()] before you may call this function.
    #[doc(alias = "g_main_context_dispatch")]
    pub fn dispatch(&self) {
        unsafe {
            ffi::g_main_context_dispatch(self.to_glib_none().0);
        }
    }

    //#[doc(alias = "g_main_context_find_source_by_funcs_user_data")]
    //pub fn find_source_by_funcs_user_data(&self, funcs: /*Ignored*/&mut SourceFuncs, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Source {
    //    unsafe { TODO: call ffi:g_main_context_find_source_by_funcs_user_data() }
    //}

    //#[doc(alias = "g_main_context_find_source_by_user_data")]
    //pub fn find_source_by_user_data(&self, user_data: /*Unimplemented*/Option<Fundamental: Pointer>) -> Source {
    //    unsafe { TODO: call ffi:g_main_context_find_source_by_user_data() }
    //}

    //#[doc(alias = "g_main_context_get_poll_func")]
    //#[doc(alias = "get_poll_func")]
    //pub fn poll_func(&self) -> /*Unimplemented*/Fn(/*Ignored*/PollFD, u32, i32) -> i32 {
    //    unsafe { TODO: call ffi:g_main_context_get_poll_func() }
    //}

    /// Determines whether this thread holds the (recursive)
    /// ownership of this [`MainContext`][crate::MainContext]. This is useful to
    /// know before waiting on another thread that may be
    /// blocking to get ownership of `self`.
    ///
    /// # Returns
    ///
    /// [`true`] if current thread is owner of `self`.
    #[doc(alias = "g_main_context_is_owner")]
    pub fn is_owner(&self) -> bool {
        unsafe { from_glib(ffi::g_main_context_is_owner(self.to_glib_none().0)) }
    }

    /// Runs a single iteration for the given main loop. This involves
    /// checking to see if any event sources are ready to be processed,
    /// then if no events sources are ready and `may_block` is [`true`], waiting
    /// for a source to become ready, then dispatching the highest priority
    /// events sources that are ready. Otherwise, if `may_block` is [`false`]
    /// sources are not waited to become ready, only those highest priority
    /// events sources will be dispatched (if any), that are ready at this
    /// given moment without further waiting.
    ///
    /// Note that even when `may_block` is [`true`], it is still possible for
    /// [`iteration()`][Self::iteration()] to return [`false`], since the wait may
    /// be interrupted for other reasons than an event source becoming ready.
    /// ## `may_block`
    /// whether the call may block.
    ///
    /// # Returns
    ///
    /// [`true`] if events were dispatched.
    #[doc(alias = "g_main_context_iteration")]
    pub fn iteration(&self, may_block: bool) -> bool {
        unsafe {
            from_glib(ffi::g_main_context_iteration(
                self.to_glib_none().0,
                may_block.into_glib(),
            ))
        }
    }

    /// Checks if any sources have pending events for the given context.
    ///
    /// # Returns
    ///
    /// [`true`] if events are pending.
    #[doc(alias = "g_main_context_pending")]
    pub fn pending(&self) -> bool {
        unsafe { from_glib(ffi::g_main_context_pending(self.to_glib_none().0)) }
    }

    /// Pops `self` off the thread-default context stack (verifying that
    /// it was on the top of the stack).
    #[doc(alias = "g_main_context_pop_thread_default")]
    pub fn pop_thread_default(&self) {
        unsafe {
            ffi::g_main_context_pop_thread_default(self.to_glib_none().0);
        }
    }

    /// Acquires `self` and sets it as the thread-default context for the
    /// current thread. This will cause certain asynchronous operations
    /// (such as most [gio][gio]-based I/O) which are
    /// started in this thread to run under `self` and deliver their
    /// results to its main loop, rather than running under the global
    /// default context in the main thread. Note that calling this function
    /// changes the context returned by [`thread_default()`][Self::thread_default()],
    /// not the one returned by [`default()`][Self::default()], so it does not affect
    /// the context used by functions like `g_idle_add()`.
    ///
    /// Normally you would call this function shortly after creating a new
    /// thread, passing it a [`MainContext`][crate::MainContext] which will be run by a
    /// [`MainLoop`][crate::MainLoop] in that thread, to set a new default context for all
    /// async operations in that thread. In this case you may not need to
    /// ever call [`pop_thread_default()`][Self::pop_thread_default()], assuming you want the
    /// new [`MainContext`][crate::MainContext] to be the default for the whole lifecycle of the
    /// thread.
    ///
    /// If you don't have control over how the new thread was created (e.g.
    /// in the new thread isn't newly created, or if the thread life
    /// cycle is managed by a `GThreadPool`), it is always suggested to wrap
    /// the logic that needs to use the new [`MainContext`][crate::MainContext] inside a
    /// [`push_thread_default()`][Self::push_thread_default()] / [`pop_thread_default()`][Self::pop_thread_default()]
    /// pair, otherwise threads that are re-used will end up never explicitly
    /// releasing the [`MainContext`][crate::MainContext] reference they hold.
    ///
    /// In some cases you may want to schedule a single operation in a
    /// non-default context, or temporarily use a non-default context in
    /// the main thread. In that case, you can wrap the call to the
    /// asynchronous operation inside a
    /// [`push_thread_default()`][Self::push_thread_default()] /
    /// [`pop_thread_default()`][Self::pop_thread_default()] pair, but it is up to you to
    /// ensure that no other asynchronous operations accidentally get
    /// started while the non-default context is active.
    ///
    /// Beware that libraries that predate this function may not correctly
    /// handle being used from a thread with a thread-default context. Eg,
    /// see `g_file_supports_thread_contexts()`.
    #[doc(alias = "g_main_context_push_thread_default")]
    pub fn push_thread_default(&self) {
        unsafe {
            ffi::g_main_context_push_thread_default(self.to_glib_none().0);
        }
    }

    //#[doc(alias = "g_main_context_query")]
    //pub fn query(&self, max_priority: i32, fds: /*Ignored*/Vec<PollFD>) -> (i32, i32) {
    //    unsafe { TODO: call ffi:g_main_context_query() }
    //}

    //#[doc(alias = "g_main_context_remove_poll")]
    //pub fn remove_poll(&self, fd: /*Ignored*/&mut PollFD) {
    //    unsafe { TODO: call ffi:g_main_context_remove_poll() }
    //}

    //#[doc(alias = "g_main_context_set_poll_func")]
    //pub fn set_poll_func(&self, func: /*Unimplemented*/Fn(/*Ignored*/PollFD, u32, i32) -> i32) {
    //    unsafe { TODO: call ffi:g_main_context_set_poll_func() }
    //}

    //#[cfg_attr(feature = "v2_58", deprecated = "Since 2.58")]
    //#[doc(alias = "g_main_context_wait")]
    //pub fn wait(&self, cond: /*Ignored*/&mut Cond, mutex: /*Ignored*/&mut Mutex) -> bool {
    //    unsafe { TODO: call ffi:g_main_context_wait() }
    //}

    /// If `self` is currently blocking in [`iteration()`][Self::iteration()]
    /// waiting for a source to become ready, cause it to stop blocking
    /// and return. Otherwise, cause the next invocation of
    /// [`iteration()`][Self::iteration()] to return without blocking.
    ///
    /// This API is useful for low-level control over [`MainContext`][crate::MainContext]; for
    /// example, integrating it with main loop implementations such as
    /// [`MainLoop`][crate::MainLoop].
    ///
    /// Another related use for this function is when implementing a main
    /// loop with a termination condition, computed from multiple threads:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   #define NUM_TASKS 10
    ///   static gint tasks_remaining = NUM_TASKS;  // (atomic)
    ///   ...
    ///
    ///   while (g_atomic_int_get (&tasks_remaining) != 0)
    ///     g_main_context_iteration (NULL, TRUE);
    /// ```
    ///
    /// Then in a thread:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   perform_work();
    ///
    ///   if (g_atomic_int_dec_and_test (&tasks_remaining))
    ///     g_main_context_wakeup (NULL);
    /// ```
    #[doc(alias = "g_main_context_wakeup")]
    pub fn wakeup(&self) {
        unsafe {
            ffi::g_main_context_wakeup(self.to_glib_none().0);
        }
    }

    /// Returns the global default main context. This is the main context
    /// used for main loop functions when a main loop is not explicitly
    /// specified, and corresponds to the "main" main loop. See also
    /// [`thread_default()`][Self::thread_default()].
    ///
    /// # Returns
    ///
    /// the global default main context.
    #[doc(alias = "g_main_context_default")]
    pub fn default() -> MainContext {
        unsafe { from_glib_none(ffi::g_main_context_default()) }
    }

    /// Gets the thread-default [`MainContext`][crate::MainContext] for this thread. Asynchronous
    /// operations that want to be able to be run in contexts other than
    /// the default one should call this method or
    /// [`ref_thread_default()`][Self::ref_thread_default()] to get a [`MainContext`][crate::MainContext] to add
    /// their `GSources` to. (Note that even in single-threaded
    /// programs applications may sometimes want to temporarily push a
    /// non-default context, so it is not safe to assume that this will
    /// always return [`None`] if you are running in the default thread.)
    ///
    /// If you need to hold a reference on the context, use
    /// [`ref_thread_default()`][Self::ref_thread_default()] instead.
    ///
    /// # Returns
    ///
    /// the thread-default [`MainContext`][crate::MainContext], or
    /// [`None`] if the thread-default context is the global default context.
    #[doc(alias = "g_main_context_get_thread_default")]
    #[doc(alias = "get_thread_default")]
    pub fn thread_default() -> Option<MainContext> {
        unsafe { from_glib_none(ffi::g_main_context_get_thread_default()) }
    }

    /// Gets the thread-default [`MainContext`][crate::MainContext] for this thread, as with
    /// [`thread_default()`][Self::thread_default()], but also adds a reference to
    /// it with `g_main_context_ref()`. In addition, unlike
    /// [`thread_default()`][Self::thread_default()], if the thread-default context
    /// is the global default context, this will return that [`MainContext`][crate::MainContext]
    /// (with a ref added to it) rather than returning [`None`].
    ///
    /// # Returns
    ///
    /// the thread-default [`MainContext`][crate::MainContext]. Unref
    ///  with `g_main_context_unref()` when you are done with it.
    #[doc(alias = "g_main_context_ref_thread_default")]
    pub fn ref_thread_default() -> MainContext {
        unsafe { from_glib_full(ffi::g_main_context_ref_thread_default()) }
    }
}

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

unsafe impl Send for MainContext {}
unsafe impl Sync for MainContext {}