// 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 glib;
use glib::object::IsA;
use glib::translate::*;
use gst;
use gst_gl_sys;
use std::mem;
use std::ptr;
use GLDisplay;
use GLPlatform;
use GLSLProfile;
use GLSLVersion;
use GLWindow;
use GLAPI;

glib_wrapper! {
    /// `GLContext` wraps an OpenGL context object in a uniform API. As a result
    /// of the limitation on OpenGL context, this object is not thread safe unless
    /// specified and must only be activated in a single thread.
    ///
    /// # Implements
    ///
    /// [`GLContextExt`](trait.GLContextExt.html), [`gst::ObjectExt`](../gst/trait.ObjectExt.html), [`glib::object::ObjectExt`](../glib/object/trait.ObjectExt.html), [`GLContextExtManual`](prelude/trait.GLContextExtManual.html)
    pub struct GLContext(Object<gst_gl_sys::GstGLContext, gst_gl_sys::GstGLContextClass, GLContextClass>) @extends gst::Object;

    match fn {
        get_type => || gst_gl_sys::gst_gl_context_get_type(),
    }
}

impl GLContext {
    /// Create a new `GLContext` with the specified `display`
    /// ## `display`
    /// a `GLDisplay`
    ///
    /// # Returns
    ///
    /// a new `GLContext`
    pub fn new<P: IsA<GLDisplay>>(display: &P) -> GLContext {
        skip_assert_initialized!();
        unsafe {
            from_glib_none(gst_gl_sys::gst_gl_context_new(
                display.as_ref().to_glib_none().0,
            ))
        }
    }

    /// See also `GLContextExt::activate`.
    ///
    /// # Returns
    ///
    /// the `GLContext` active in the current thread or `None`
    pub fn get_current() -> Option<GLContext> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(gst_gl_sys::gst_gl_context_get_current()) }
    }

    /// If an error occurs, `major` and `minor` are not modified and `GLAPI::None` is
    /// returned.
    /// ## `platform`
    /// the `GLPlatform` to retrieve the API for
    /// ## `major`
    /// the major version
    /// ## `minor`
    /// the minor version
    ///
    /// # Returns
    ///
    /// The version supported by the OpenGL context current in the calling
    ///  thread or `GLAPI::None`
    pub fn get_current_gl_api(platform: GLPlatform) -> (GLAPI, u32, u32) {
        assert_initialized_main_thread!();
        unsafe {
            let mut major = mem::MaybeUninit::uninit();
            let mut minor = mem::MaybeUninit::uninit();
            let ret = from_glib(gst_gl_sys::gst_gl_context_get_current_gl_api(
                platform.to_glib(),
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
            ));
            let major = major.assume_init();
            let minor = minor.assume_init();
            (ret, major, minor)
        }
    }
}

unsafe impl Send for GLContext {}
unsafe impl Sync for GLContext {}

pub const NONE_GL_CONTEXT: Option<&GLContext> = None;

/// Trait containing all `GLContext` methods.
///
/// # Implementors
///
/// [`GLContext`](struct.GLContext.html)
pub trait GLContextExt: 'static {
    /// (De)activate the OpenGL context represented by this `self`.
    ///
    /// In OpenGL terms, calls eglMakeCurrent or similar with this context and the
    /// currently set window. See `GLContextExt::set_window` for details.
    /// ## `activate`
    /// `true` to activate, `false` to deactivate
    ///
    /// # Returns
    ///
    /// Whether the activation succeeded
    fn activate(&self, activate: bool) -> Result<(), glib::error::BoolError>;

    /// Note: This will always fail for two wrapped `GLContext`'s
    /// ## `other_context`
    /// another `GLContext`
    ///
    /// # Returns
    ///
    /// whether `self` and `other_context` are able to share OpenGL
    ///  resources.
    fn can_share<P: IsA<GLContext>>(&self, other_context: &P) -> bool;

    /// Check for an OpenGL `feature` being supported.
    ///
    /// Note: Most features require that the context be created before it is
    /// possible to determine their existence and so will fail if that is not the
    /// case.
    /// ## `feature`
    /// a platform specific feature
    ///
    /// # Returns
    ///
    /// Whether `feature` is supported by `self`
    fn check_feature(&self, feature: &str) -> bool;

    /// ## `fbo_target`
    /// the GL value of the framebuffer target, GL_FRAMEBUFFER,
    ///  GL_READ_FRAMEBUFFER, GL_DRAW_FRAMEBUFFER
    ///
    /// # Returns
    ///
    /// whether whether the current framebuffer is complete
    fn check_framebuffer_status(&self, fbo_target: u32) -> bool;

    /// ## `api`
    /// api type required
    /// ## `maj`
    /// major version required
    /// ## `min`
    /// minor version required
    ///
    /// # Returns
    ///
    /// whether OpenGL context implements the required api and specified
    /// version.
    fn check_gl_version(&self, api: GLAPI, maj: i32, min: i32) -> bool;

    /// Unbind the current framebuffer
    fn clear_framebuffer(&self);

    /// Clear's the currently set shader from the GL state machine.
    ///
    /// Note: must be called in the GL thread.
    fn clear_shader(&self);

    /// Creates an OpenGL context with the specified `other_context` as a context
    /// to share shareable OpenGL objects with. See the OpenGL specification for
    /// what is shared between OpenGL contexts.
    ///
    /// If an error occurs, and `error` is not `None`, then error will contain details
    /// of the error and `false` will be returned.
    ///
    /// Should only be called once.
    /// ## `other_context`
    /// a `GLContext` to share OpenGL objects with
    ///
    /// # Returns
    ///
    /// whether the context could successfully be created
    fn create<P: IsA<GLContext>>(&self, other_context: Option<&P>) -> Result<(), glib::Error>;

    /// Destroys an OpenGL context.
    ///
    /// Should only be called after `GLContextExt::create` has been successfully
    /// called for this context.
    fn destroy(&self);

    /// Fills `self`'s info (version, extensions, vtable, etc) from the GL
    /// context in the current thread. Typically used with wrapped contexts to
    /// allow wrapped contexts to be used as regular `GLContext`'s.
    fn fill_info(&self) -> Result<(), glib::Error>;

    ///
    /// # Returns
    ///
    /// the `GLDisplay` associated with this `self`
    fn get_display(&self) -> GLDisplay;

    /// Get the currently enabled OpenGL api.
    ///
    /// The currently available API may be limited by the `GLDisplay` in use and/or
    /// the `GLWindow` chosen.
    ///
    /// # Returns
    ///
    /// the available OpenGL api
    fn get_gl_api(&self) -> GLAPI;

    /// Gets the OpenGL platform that used by `self`.
    ///
    /// # Returns
    ///
    /// The platform specific backing OpenGL context
    fn get_gl_platform(&self) -> GLPlatform;

    /// Get the version of the OpenGL platform (GLX, EGL, etc) used. Only valid
    /// after a call to `GLContextExt::create`.
    /// ## `major`
    /// return for the major version
    /// ## `minor`
    /// return for the minor version
    fn get_gl_platform_version(&self) -> (i32, i32);

    /// Returns the OpenGL version implemented by `self`. See
    /// `GLContextExt::get_gl_api` for retrieving the OpenGL api implemented by
    /// `self`.
    /// ## `maj`
    /// resulting major version
    /// ## `min`
    /// resulting minor version
    fn get_gl_version(&self) -> (i32, i32);

    ///
    /// # Returns
    ///
    /// the currently set window
    fn get_window(&self) -> Option<GLWindow>;

    ///
    /// # Returns
    ///
    /// Whether the `GLContext` has been shared with another `GLContext`
    fn is_shared(&self) -> bool;

    /// Will internally set `self` as shared with `share`
    /// ## `share`
    /// another `GLContext`
    fn set_shared_with<P: IsA<GLContext>>(&self, share: &P);

    /// Set's the current window on `self` to `window`. The window can only be
    /// changed before `GLContextExt::create` has been called and the `window` is not
    /// already running.
    /// ## `window`
    /// a `GLWindow`
    ///
    /// # Returns
    ///
    /// Whether the window was successfully updated
    fn set_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError>;

    /// ## `version`
    /// a `GLSLVersion`
    /// ## `profile`
    /// a `GLSLProfile`
    ///
    /// # Returns
    ///
    /// Whether `self` supports the combination of `version` with `profile`
    fn supports_glsl_profile_version(&self, version: GLSLVersion, profile: GLSLProfile) -> bool;

    ///
    /// Feature: `v1_16`
    ///
    /// ## `version`
    /// a `GLSLVersion`
    /// ## `profile`
    /// a `GLSLProfile`
    ///
    /// # Returns
    ///
    /// whether `self` supports the 'precision' specifier in GLSL shaders
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn supports_precision(&self, version: GLSLVersion, profile: GLSLProfile) -> bool;

    ///
    /// Feature: `v1_16`
    ///
    /// ## `version`
    /// a `GLSLVersion`
    /// ## `profile`
    /// a `GLSLProfile`
    ///
    /// # Returns
    ///
    /// whether `self` supports the 'precision highp' specifier in GLSL shaders
    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn supports_precision_highp(&self, version: GLSLVersion, profile: GLSLProfile) -> bool;

    /// Swap the front and back buffers on the window attached to `self`.
    /// This will display the frame on the next refresh cycle.
    fn swap_buffers(&self);
}

impl<O: IsA<GLContext>> GLContextExt for O {
    fn activate(&self, activate: bool) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_gl_sys::gst_gl_context_activate(
                    self.as_ref().to_glib_none().0,
                    activate.to_glib()
                ),
                "Failed to activate OpenGL context"
            )
        }
    }

    fn can_share<P: IsA<GLContext>>(&self, other_context: &P) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_can_share(
                self.as_ref().to_glib_none().0,
                other_context.as_ref().to_glib_none().0,
            ))
        }
    }

    fn check_feature(&self, feature: &str) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_check_feature(
                self.as_ref().to_glib_none().0,
                feature.to_glib_none().0,
            ))
        }
    }

    fn check_framebuffer_status(&self, fbo_target: u32) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_check_framebuffer_status(
                self.as_ref().to_glib_none().0,
                fbo_target,
            ))
        }
    }

    fn check_gl_version(&self, api: GLAPI, maj: i32, min: i32) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_check_gl_version(
                self.as_ref().to_glib_none().0,
                api.to_glib(),
                maj,
                min,
            ))
        }
    }

    fn clear_framebuffer(&self) {
        unsafe {
            gst_gl_sys::gst_gl_context_clear_framebuffer(self.as_ref().to_glib_none().0);
        }
    }

    fn clear_shader(&self) {
        unsafe {
            gst_gl_sys::gst_gl_context_clear_shader(self.as_ref().to_glib_none().0);
        }
    }

    fn create<P: IsA<GLContext>>(&self, other_context: Option<&P>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = gst_gl_sys::gst_gl_context_create(
                self.as_ref().to_glib_none().0,
                other_context.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn destroy(&self) {
        unsafe {
            gst_gl_sys::gst_gl_context_destroy(self.as_ref().to_glib_none().0);
        }
    }

    fn fill_info(&self) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ =
                gst_gl_sys::gst_gl_context_fill_info(self.as_ref().to_glib_none().0, &mut error);
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn get_display(&self) -> GLDisplay {
        unsafe {
            from_glib_full(gst_gl_sys::gst_gl_context_get_display(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_gl_api(&self) -> GLAPI {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_get_gl_api(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_gl_platform(&self) -> GLPlatform {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_get_gl_platform(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_gl_platform_version(&self) -> (i32, i32) {
        unsafe {
            let mut major = mem::MaybeUninit::uninit();
            let mut minor = mem::MaybeUninit::uninit();
            gst_gl_sys::gst_gl_context_get_gl_platform_version(
                self.as_ref().to_glib_none().0,
                major.as_mut_ptr(),
                minor.as_mut_ptr(),
            );
            let major = major.assume_init();
            let minor = minor.assume_init();
            (major, minor)
        }
    }

    fn get_gl_version(&self) -> (i32, i32) {
        unsafe {
            let mut maj = mem::MaybeUninit::uninit();
            let mut min = mem::MaybeUninit::uninit();
            gst_gl_sys::gst_gl_context_get_gl_version(
                self.as_ref().to_glib_none().0,
                maj.as_mut_ptr(),
                min.as_mut_ptr(),
            );
            let maj = maj.assume_init();
            let min = min.assume_init();
            (maj, min)
        }
    }

    fn get_window(&self) -> Option<GLWindow> {
        unsafe {
            from_glib_full(gst_gl_sys::gst_gl_context_get_window(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_shared(&self) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_is_shared(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn set_shared_with<P: IsA<GLContext>>(&self, share: &P) {
        unsafe {
            gst_gl_sys::gst_gl_context_set_shared_with(
                self.as_ref().to_glib_none().0,
                share.as_ref().to_glib_none().0,
            );
        }
    }

    fn set_window<P: IsA<GLWindow>>(&self, window: &P) -> Result<(), glib::error::BoolError> {
        unsafe {
            glib_result_from_gboolean!(
                gst_gl_sys::gst_gl_context_set_window(
                    self.as_ref().to_glib_none().0,
                    window.as_ref().to_glib_full()
                ),
                "Failed to set window"
            )
        }
    }

    fn supports_glsl_profile_version(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_supports_glsl_profile_version(
                self.as_ref().to_glib_none().0,
                version.to_glib(),
                profile.to_glib(),
            ))
        }
    }

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn supports_precision(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_supports_precision(
                self.as_ref().to_glib_none().0,
                version.to_glib(),
                profile.to_glib(),
            ))
        }
    }

    #[cfg(any(feature = "v1_16", feature = "dox"))]
    fn supports_precision_highp(&self, version: GLSLVersion, profile: GLSLProfile) -> bool {
        unsafe {
            from_glib(gst_gl_sys::gst_gl_context_supports_precision_highp(
                self.as_ref().to_glib_none().0,
                version.to_glib(),
                profile.to_glib(),
            ))
        }
    }

    fn swap_buffers(&self) {
        unsafe {
            gst_gl_sys::gst_gl_context_swap_buffers(self.as_ref().to_glib_none().0);
        }
    }
}