// 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
#![allow(deprecated)]

use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// [`MediaStream`][crate::MediaStream] is the integration point for media playback inside GTK.
    ///
    /// GTK provides an implementation of the [`MediaStream`][crate::MediaStream] interface that
    /// is called [`MediaFile`][crate::MediaFile].
    ///
    /// Apart from application-facing API for stream playback, [`MediaStream`][crate::MediaStream]
    /// has a number of APIs that are only useful for implementations and should
    /// not be used in applications:
    /// [`MediaStreamExt::prepared()`][crate::prelude::MediaStreamExt::prepared()],
    /// [`MediaStreamExt::unprepared()`][crate::prelude::MediaStreamExt::unprepared()],
    /// [`MediaStreamExt::update()`][crate::prelude::MediaStreamExt::update()],
    /// [`MediaStreamExt::ended()`][crate::prelude::MediaStreamExt::ended()],
    /// [`MediaStreamExt::seek_success()`][crate::prelude::MediaStreamExt::seek_success()],
    /// [`MediaStreamExt::seek_failed()`][crate::prelude::MediaStreamExt::seek_failed()],
    /// [`MediaStreamExtManual::set_error()`][crate::prelude::MediaStreamExtManual::set_error()],
    /// `Gtk::MediaStream::error()`,
    /// `Gtk::MediaStream::error_valist()`.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `duration`
    ///  The stream's duration in microseconds or 0 if unknown.
    ///
    /// Readable
    ///
    ///
    /// #### `ended`
    ///  Set when playback has finished.
    ///
    /// Readable
    ///
    ///
    /// #### `error`
    ///  [`None`] for a properly working stream or the `GError`
    /// that the stream is in.
    ///
    /// Readable
    ///
    ///
    /// #### `has-audio`
    ///  Whether the stream contains audio.
    ///
    /// Readable
    ///
    ///
    /// #### `has-video`
    ///  Whether the stream contains video.
    ///
    /// Readable
    ///
    ///
    /// #### `loop`
    ///  Try to restart the media from the beginning once it ended.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `muted`
    ///  Whether the audio stream should be muted.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `playing`
    ///  Whether the stream is currently playing.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `prepared`
    ///  Whether the stream has finished initializing and existence of
    /// audio and video is known.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `seekable`
    ///  Set unless the stream is known to not support seeking.
    ///
    /// Readable
    ///
    ///
    /// #### `seeking`
    ///  Set while a seek is in progress.
    ///
    /// Readable
    ///
    ///
    /// #### `timestamp`
    ///  The current presentation timestamp in microseconds.
    ///
    /// Readable
    ///
    ///
    /// #### `volume`
    ///  Volume of the audio stream.
    ///
    /// Readable | Writeable
    ///
    /// # Implements
    ///
    /// [`MediaStreamExt`][trait@crate::prelude::MediaStreamExt], [`trait@glib::ObjectExt`], [`trait@gdk::prelude::PaintableExt`], [`MediaStreamExtManual`][trait@crate::prelude::MediaStreamExtManual]
    #[doc(alias = "GtkMediaStream")]
    pub struct MediaStream(Object<ffi::GtkMediaStream, ffi::GtkMediaStreamClass>) @implements gdk::Paintable;

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

impl MediaStream {
    pub const NONE: Option<&'static MediaStream> = None;
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::MediaStream>> Sealed for T {}
}

/// Trait containing all [`struct@MediaStream`] methods.
///
/// # Implementors
///
/// [`MediaFile`][struct@crate::MediaFile], [`MediaStream`][struct@crate::MediaStream]
pub trait MediaStreamExt: IsA<MediaStream> + sealed::Sealed + 'static {
    /// Pauses the media stream and marks it as ended.
    ///
    /// This is a hint only, calls to [`play()`][Self::play()]
    /// may still happen.
    ///
    /// The media stream must be prepared when this function is called.
    ///
    /// # Deprecated since 4.4
    ///
    /// Use [`stream_ended()`][Self::stream_ended()] instead
    #[cfg_attr(feature = "v4_4", deprecated = "Since 4.4")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_media_stream_ended")]
    fn ended(&self) {
        unsafe {
            ffi::gtk_media_stream_ended(self.as_ref().to_glib_none().0);
        }
    }

    /// Gets the duration of the stream.
    ///
    /// If the duration is not known, 0 will be returned.
    ///
    /// # Returns
    ///
    /// the duration of the stream or 0 if not known.
    #[doc(alias = "gtk_media_stream_get_duration")]
    #[doc(alias = "get_duration")]
    fn duration(&self) -> i64 {
        unsafe { ffi::gtk_media_stream_get_duration(self.as_ref().to_glib_none().0) }
    }

    /// Returns whether the streams playback is finished.
    ///
    /// # Returns
    ///
    /// [`true`] if playback is finished
    #[doc(alias = "gtk_media_stream_get_ended")]
    #[doc(alias = "get_ended")]
    fn is_ended(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_get_ended(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// If the stream is in an error state, returns the `GError`
    /// explaining that state.
    ///
    /// Any type of error can be reported here depending on the
    /// implementation of the media stream.
    ///
    /// A media stream in an error cannot be operated on, calls
    /// like [`play()`][Self::play()] or
    /// [`seek()`][Self::seek()] will not have any effect.
    ///
    /// [`MediaStream`][crate::MediaStream] itself does not provide a way to unset
    /// an error, but implementations may provide options. For example,
    /// a [`MediaFile`][crate::MediaFile] will unset errors when a new source is
    /// set, e.g. with [`MediaFileExt::set_file()`][crate::prelude::MediaFileExt::set_file()].
    ///
    /// # Returns
    ///
    /// [`None`] if not in an
    ///   error state or the `GError` of the stream
    #[doc(alias = "gtk_media_stream_get_error")]
    #[doc(alias = "get_error")]
    fn error(&self) -> Option<glib::Error> {
        unsafe {
            from_glib_none(ffi::gtk_media_stream_get_error(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the stream is set to loop.
    ///
    /// See [`set_loop()`][Self::set_loop()] for details.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream should loop
    #[doc(alias = "gtk_media_stream_get_loop")]
    #[doc(alias = "get_loop")]
    fn is_loop(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_get_loop(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the audio for the stream is muted.
    ///
    /// See [`set_muted()`][Self::set_muted()] for details.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream is muted
    #[doc(alias = "gtk_media_stream_get_muted")]
    #[doc(alias = "get_muted")]
    fn is_muted(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_get_muted(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Return whether the stream is currently playing.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream is playing
    #[doc(alias = "gtk_media_stream_get_playing")]
    #[doc(alias = "get_playing")]
    fn is_playing(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_get_playing(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the current presentation timestamp in microseconds.
    ///
    /// # Returns
    ///
    /// the timestamp in microseconds
    #[doc(alias = "gtk_media_stream_get_timestamp")]
    #[doc(alias = "get_timestamp")]
    fn timestamp(&self) -> i64 {
        unsafe { ffi::gtk_media_stream_get_timestamp(self.as_ref().to_glib_none().0) }
    }

    /// Returns the volume of the audio for the stream.
    ///
    /// See [`set_volume()`][Self::set_volume()] for details.
    ///
    /// # Returns
    ///
    /// volume of the stream from 0.0 to 1.0
    #[doc(alias = "gtk_media_stream_get_volume")]
    #[doc(alias = "get_volume")]
    fn volume(&self) -> f64 {
        unsafe { ffi::gtk_media_stream_get_volume(self.as_ref().to_glib_none().0) }
    }

    /// Returns whether the stream has audio.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream has audio
    #[doc(alias = "gtk_media_stream_has_audio")]
    fn has_audio(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_has_audio(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the stream has video.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream has video
    #[doc(alias = "gtk_media_stream_has_video")]
    fn has_video(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_has_video(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the stream has finished initializing.
    ///
    /// At this point the existence of audio and video is known.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream is prepared
    #[doc(alias = "gtk_media_stream_is_prepared")]
    fn is_prepared(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_is_prepared(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if a stream may be seekable.
    ///
    /// This is meant to be a hint. Streams may not allow seeking even if
    /// this function returns [`true`]. However, if this function returns
    /// [`false`], streams are guaranteed to not be seekable and user interfaces
    /// may hide controls that allow seeking.
    ///
    /// It is allowed to call [`seek()`][Self::seek()] on a non-seekable
    /// stream, though it will not do anything.
    ///
    /// # Returns
    ///
    /// [`true`] if the stream may support seeking
    #[doc(alias = "gtk_media_stream_is_seekable")]
    fn is_seekable(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_is_seekable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if there is currently a seek operation going on.
    ///
    /// # Returns
    ///
    /// [`true`] if a seek operation is ongoing.
    #[doc(alias = "gtk_media_stream_is_seeking")]
    fn is_seeking(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_media_stream_is_seeking(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Pauses playback of the stream.
    ///
    /// If the stream is not playing, do nothing.
    #[doc(alias = "gtk_media_stream_pause")]
    fn pause(&self) {
        unsafe {
            ffi::gtk_media_stream_pause(self.as_ref().to_glib_none().0);
        }
    }

    /// Starts playing the stream.
    ///
    /// If the stream is in error or already playing, do nothing.
    #[doc(alias = "gtk_media_stream_play")]
    fn play(&self) {
        unsafe {
            ffi::gtk_media_stream_play(self.as_ref().to_glib_none().0);
        }
    }

    /// Same as gtk_media_stream_stream_prepared().
    ///
    /// # Deprecated since 4.4
    ///
    /// Use [`stream_prepared()`][Self::stream_prepared()] instead.
    /// ## `has_audio`
    /// [`true`] if the stream should advertise audio support
    /// ## `has_video`
    /// [`true`] if the stream should advertise video support
    /// ## `seekable`
    /// [`true`] if the stream should advertise seekability
    /// ## `duration`
    /// The duration of the stream or 0 if unknown
    #[cfg_attr(feature = "v4_4", deprecated = "Since 4.4")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_media_stream_prepared")]
    fn prepared(&self, has_audio: bool, has_video: bool, seekable: bool, duration: i64) {
        unsafe {
            ffi::gtk_media_stream_prepared(
                self.as_ref().to_glib_none().0,
                has_audio.into_glib(),
                has_video.into_glib(),
                seekable.into_glib(),
                duration,
            );
        }
    }

    /// Called by users to attach the media stream to a [`gdk::Surface`][crate::gdk::Surface] they manage.
    ///
    /// The stream can then access the resources of @surface for its
    /// rendering purposes. In particular, media streams might want to
    /// create a [`gdk::GLContext`][crate::gdk::GLContext] or sync to the [`gdk::FrameClock`][crate::gdk::FrameClock].
    ///
    /// Whoever calls this function is responsible for calling
    /// [`unrealize()`][Self::unrealize()] before either the stream
    /// or @surface get destroyed.
    ///
    /// Multiple calls to this function may happen from different
    /// users of the video, even with the same @surface. Each of these
    /// calls must be followed by its own call to
    /// [`unrealize()`][Self::unrealize()].
    ///
    /// It is not required to call this function to make a media stream work.
    /// ## `surface`
    /// a [`gdk::Surface`][crate::gdk::Surface]
    #[doc(alias = "gtk_media_stream_realize")]
    fn realize(&self, surface: &impl IsA<gdk::Surface>) {
        unsafe {
            ffi::gtk_media_stream_realize(
                self.as_ref().to_glib_none().0,
                surface.as_ref().to_glib_none().0,
            );
        }
    }

    /// Start a seek operation on @self to @timestamp.
    ///
    /// If @timestamp is out of range, it will be clamped.
    ///
    /// Seek operations may not finish instantly. While a
    /// seek operation is in process, the [`seeking`][struct@crate::MediaStream#seeking]
    /// property will be set.
    ///
    /// When calling gtk_media_stream_seek() during an
    /// ongoing seek operation, the new seek will override
    /// any pending seek.
    /// ## `timestamp`
    /// timestamp to seek to.
    #[doc(alias = "gtk_media_stream_seek")]
    fn seek(&self, timestamp: i64) {
        unsafe {
            ffi::gtk_media_stream_seek(self.as_ref().to_glib_none().0, timestamp);
        }
    }

    /// Ends a seek operation started via GtkMediaStream.seek() as a failure.
    ///
    /// This will not cause an error on the stream and will assume that
    /// playback continues as if no seek had happened.
    ///
    /// See [`seek_success()`][Self::seek_success()] for the other way of
    /// ending a seek.
    #[doc(alias = "gtk_media_stream_seek_failed")]
    fn seek_failed(&self) {
        unsafe {
            ffi::gtk_media_stream_seek_failed(self.as_ref().to_glib_none().0);
        }
    }

    /// Ends a seek operation started via GtkMediaStream.seek() successfully.
    ///
    /// This function will unset the GtkMediaStream:ended property
    /// if it was set.
    ///
    /// See [`seek_failed()`][Self::seek_failed()] for the other way of
    /// ending a seek.
    #[doc(alias = "gtk_media_stream_seek_success")]
    fn seek_success(&self) {
        unsafe {
            ffi::gtk_media_stream_seek_success(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets whether the stream should loop.
    ///
    /// In this case, it will attempt to restart playback
    /// from the beginning instead of stopping at the end.
    ///
    /// Not all streams may support looping, in particular
    /// non-seekable streams. Those streams will ignore the
    /// loop setting and just end.
    /// ## `loop_`
    /// [`true`] if the stream should loop
    #[doc(alias = "gtk_media_stream_set_loop")]
    fn set_loop(&self, loop_: bool) {
        unsafe {
            ffi::gtk_media_stream_set_loop(self.as_ref().to_glib_none().0, loop_.into_glib());
        }
    }

    /// Sets whether the audio stream should be muted.
    ///
    /// Muting a stream will cause no audio to be played, but it
    /// does not modify the volume. This means that muting and
    /// then unmuting the stream will restore the volume settings.
    ///
    /// If the stream has no audio, calling this function will
    /// still work but it will not have an audible effect.
    /// ## `muted`
    /// [`true`] if the stream should be muted
    #[doc(alias = "gtk_media_stream_set_muted")]
    fn set_muted(&self, muted: bool) {
        unsafe {
            ffi::gtk_media_stream_set_muted(self.as_ref().to_glib_none().0, muted.into_glib());
        }
    }

    /// Starts or pauses playback of the stream.
    /// ## `playing`
    /// whether to start or pause playback
    #[doc(alias = "gtk_media_stream_set_playing")]
    fn set_playing(&self, playing: bool) {
        unsafe {
            ffi::gtk_media_stream_set_playing(self.as_ref().to_glib_none().0, playing.into_glib());
        }
    }

    /// Sets the volume of the audio stream.
    ///
    /// This function call will work even if the stream is muted.
    ///
    /// The given @volume should range from 0.0 for silence to 1.0
    /// for as loud as possible. Values outside of this range will
    /// be clamped to the nearest value.
    ///
    /// If the stream has no audio or is muted, calling this function
    /// will still work but it will not have an immediate audible effect.
    /// When the stream is unmuted, the new volume setting will take effect.
    /// ## `volume`
    /// New volume of the stream from 0.0 to 1.0
    #[doc(alias = "gtk_media_stream_set_volume")]
    fn set_volume(&self, volume: f64) {
        unsafe {
            ffi::gtk_media_stream_set_volume(self.as_ref().to_glib_none().0, volume);
        }
    }

    /// Pauses the media stream and marks it as ended.
    ///
    /// This is a hint only, calls to [`play()`][Self::play()]
    /// may still happen.
    ///
    /// The media stream must be prepared when this function is called.
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gtk_media_stream_stream_ended")]
    fn stream_ended(&self) {
        unsafe {
            ffi::gtk_media_stream_stream_ended(self.as_ref().to_glib_none().0);
        }
    }

    /// Called by [`MediaStream`][crate::MediaStream] implementations to advertise the stream
    /// being ready to play and providing details about the stream.
    ///
    /// Note that the arguments are hints. If the stream implementation
    /// cannot determine the correct values, it is better to err on the
    /// side of caution and return [`true`]. User interfaces will use those
    /// values to determine what controls to show.
    ///
    /// This function may not be called again until the stream has been
    /// reset via [`stream_unprepared()`][Self::stream_unprepared()].
    /// ## `has_audio`
    /// [`true`] if the stream should advertise audio support
    /// ## `has_video`
    /// [`true`] if the stream should advertise video support
    /// ## `seekable`
    /// [`true`] if the stream should advertise seekability
    /// ## `duration`
    /// The duration of the stream or 0 if unknown
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gtk_media_stream_stream_prepared")]
    fn stream_prepared(&self, has_audio: bool, has_video: bool, seekable: bool, duration: i64) {
        unsafe {
            ffi::gtk_media_stream_stream_prepared(
                self.as_ref().to_glib_none().0,
                has_audio.into_glib(),
                has_video.into_glib(),
                seekable.into_glib(),
                duration,
            );
        }
    }

    /// Resets a given media stream implementation.
    ///
    /// [`stream_prepared()`][Self::stream_prepared()] can then be called again.
    ///
    /// This function will also reset any error state the stream was in.
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gtk_media_stream_stream_unprepared")]
    fn stream_unprepared(&self) {
        unsafe {
            ffi::gtk_media_stream_stream_unprepared(self.as_ref().to_glib_none().0);
        }
    }

    /// Same as gtk_media_stream_stream_unprepared().
    ///
    /// # Deprecated since 4.4
    ///
    /// Use [`stream_unprepared()`][Self::stream_unprepared()] instead.
    #[cfg_attr(feature = "v4_4", deprecated = "Since 4.4")]
    #[allow(deprecated)]
    #[doc(alias = "gtk_media_stream_unprepared")]
    fn unprepared(&self) {
        unsafe {
            ffi::gtk_media_stream_unprepared(self.as_ref().to_glib_none().0);
        }
    }

    /// Undoes a previous call to gtk_media_stream_realize().
    ///
    /// This causes the stream to release all resources it had
    /// allocated from @surface.
    /// ## `surface`
    /// the [`gdk::Surface`][crate::gdk::Surface] the stream was realized with
    #[doc(alias = "gtk_media_stream_unrealize")]
    fn unrealize(&self, surface: &impl IsA<gdk::Surface>) {
        unsafe {
            ffi::gtk_media_stream_unrealize(
                self.as_ref().to_glib_none().0,
                surface.as_ref().to_glib_none().0,
            );
        }
    }

    /// Media stream implementations should regularly call this
    /// function to update the timestamp reported by the stream.
    ///
    /// It is up to implementations to call this at the frequency
    /// they deem appropriate.
    ///
    /// The media stream must be prepared when this function is called.
    /// ## `timestamp`
    /// the new timestamp
    #[doc(alias = "gtk_media_stream_update")]
    fn update(&self, timestamp: i64) {
        unsafe {
            ffi::gtk_media_stream_update(self.as_ref().to_glib_none().0, timestamp);
        }
    }

    /// Whether the stream has finished initializing and existence of
    /// audio and video is known.
    fn set_prepared(&self, prepared: bool) {
        ObjectExt::set_property(self.as_ref(), "prepared", prepared)
    }

    #[doc(alias = "duration")]
    fn connect_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_duration_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::duration\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_duration_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "ended")]
    fn connect_ended_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_ended_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::ended\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_ended_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "error")]
    fn connect_error_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_error_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::error\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_error_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-audio")]
    fn connect_has_audio_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_audio_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::has-audio\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_has_audio_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "has-video")]
    fn connect_has_video_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_video_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::has-video\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_has_video_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "loop")]
    fn connect_loop_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_loop_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::loop\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_loop_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "muted")]
    fn connect_muted_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_muted_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::muted\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_muted_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "playing")]
    fn connect_playing_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_playing_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::playing\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_playing_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "prepared")]
    fn connect_prepared_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_prepared_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::prepared\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_prepared_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "seekable")]
    fn connect_seekable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_seekable_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::seekable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_seekable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "seeking")]
    fn connect_seeking_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_seeking_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::seeking\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_seeking_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "timestamp")]
    fn connect_timestamp_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_timestamp_trampoline<
            P: IsA<MediaStream>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::timestamp\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_timestamp_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "volume")]
    fn connect_volume_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_volume_trampoline<P: IsA<MediaStream>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkMediaStream,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(MediaStream::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::volume\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_volume_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<MediaStream>> MediaStreamExt for O {}

impl fmt::Display for MediaStream {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("MediaStream")
    }
}