Update for class struct handling changes in the glib bindings

See https://github.com/gtk-rs/gtk-rs/pull/10

gstreamer-audio/src/subclass/audio_decoder.rs

@@ -23,7 +23,6 @@ use std::ptr;
 use crate::prelude::*;
 
 use AudioDecoder;
-use AudioDecoderClass;
 
 pub trait AudioDecoderImpl: AudioDecoderImplExt + ElementImpl {
     fn open(&self, element: &AudioDecoder) -> Result<(), gst::ErrorMessage> {
@@ -510,14 +509,14 @@ impl<T: AudioDecoderImpl> AudioDecoderImplExt for T {
     }
 }
 
-unsafe impl<T: AudioDecoderImpl> IsSubclassable<T> for AudioDecoderClass
+unsafe impl<T: AudioDecoderImpl> IsSubclassable<T> for AudioDecoder
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioDecoderClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioDecoderClass);
             klass.open = Some(audio_decoder_open::<T>);
             klass.close = Some(audio_decoder_close::<T>);
             klass.start = Some(audio_decoder_start::<T>);

gstreamer-audio/src/subclass/audio_encoder.rs

@@ -21,7 +21,6 @@ use std::ptr;
 use crate::prelude::*;
 
 use AudioEncoder;
-use AudioEncoderClass;
 use AudioInfo;
 
 pub trait AudioEncoderImpl: AudioEncoderImplExt + ElementImpl {
@@ -459,14 +458,14 @@ impl<T: AudioEncoderImpl> AudioEncoderImplExt for T {
     }
 }
 
-unsafe impl<T: AudioEncoderImpl> IsSubclassable<T> for AudioEncoderClass
+unsafe impl<T: AudioEncoderImpl> IsSubclassable<T> for AudioEncoder
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioEncoderClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioEncoderClass);
             klass.open = Some(audio_encoder_open::<T>);
             klass.close = Some(audio_encoder_close::<T>);
             klass.start = Some(audio_encoder_start::<T>);

gstreamer-audio/src/subclass/audio_sink.rs

@@ -10,7 +10,6 @@ use gst_base::subclass::prelude::*;
 
 use AudioRingBufferSpec;
 use AudioSink;
-use AudioSinkClass;
 
 pub trait AudioSinkImpl: AudioSinkImplExt + BaseSinkImpl {
     fn close(&self, sink: &AudioSink) -> Result<(), LoggableError> {
@@ -185,14 +184,14 @@ impl<T: AudioSinkImpl> AudioSinkImplExt for T {
     }
 }
 
-unsafe impl<T: AudioSinkImpl> IsSubclassable<T> for AudioSinkClass
+unsafe impl<T: AudioSinkImpl> IsSubclassable<T> for AudioSink
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst_base::BaseSinkClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst_base::BaseSink as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioSinkClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioSinkClass);
             klass.close = Some(audiosink_close::<T>);
             klass.delay = Some(audiosink_delay::<T>);
             klass.open = Some(audiosink_open::<T>);

gstreamer-audio/src/subclass/audio_src.rs

@@ -12,7 +12,6 @@ use gst_base::subclass::prelude::*;
 
 use AudioRingBufferSpec;
 use AudioSrc;
-use AudioSrcClass;
 
 pub trait AudioSrcImpl: AudioSrcImplExt + BaseSrcImpl {
     fn close(&self, src: &AudioSrc) -> Result<(), LoggableError> {
@@ -201,14 +200,14 @@ impl<T: AudioSrcImpl> AudioSrcImplExt for T {
     }
 }
 
-unsafe impl<T: AudioSrcImpl> IsSubclassable<T> for AudioSrcClass
+unsafe impl<T: AudioSrcImpl> IsSubclassable<T> for AudioSrc
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst_base::BaseSrcClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst_base::BaseSrc as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_audio_sys::GstAudioSrcClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_audio_sys::GstAudioSrcClass);
             klass.close = Some(audiosrc_close::<T>);
             klass.delay = Some(audiosrc_delay::<T>);
             klass.open = Some(audiosrc_open::<T>);

gstreamer-base/src/subclass/aggregator.rs

@@ -21,7 +21,6 @@ use gst::subclass::prelude::*;
 use std::ptr;
 
 use Aggregator;
-use AggregatorClass;
 use AggregatorPad;
 
 pub trait AggregatorImpl: AggregatorImplExt + ElementImpl {
@@ -673,14 +672,14 @@ impl<T: AggregatorImpl> AggregatorImplExt for T {
     }
 }
 
-unsafe impl<T: AggregatorImpl> IsSubclassable<T> for AggregatorClass
+unsafe impl<T: AggregatorImpl> IsSubclassable<T> for Aggregator
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstAggregatorClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstAggregatorClass);
             klass.flush = Some(aggregator_flush::<T>);
             klass.clip = Some(aggregator_clip::<T>);
             klass.finish_buffer = Some(aggregator_finish_buffer::<T>);

gstreamer-base/src/subclass/aggregator_pad.rs

@@ -18,7 +18,6 @@ use gst::subclass::prelude::*;
 
 use Aggregator;
 use AggregatorPad;
-use AggregatorPadClass;
 
 pub trait AggregatorPadImpl: AggregatorPadImplExt + PadImpl {
     fn flush(
@@ -100,11 +99,11 @@ impl<T: AggregatorPadImpl> AggregatorPadImplExt for T {
         }
     }
 }
-unsafe impl<T: AggregatorPadImpl> IsSubclassable<T> for AggregatorPadClass {
+unsafe impl<T: AggregatorPadImpl> IsSubclassable<T> for AggregatorPad {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::PadClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Pad as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstAggregatorPadClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstAggregatorPadClass);
             klass.flush = Some(aggregator_pad_flush::<T>);
             klass.skip_buffer = Some(aggregator_pad_skip_buffer::<T>);
         }

gstreamer-base/src/subclass/base_parse.rs

@@ -20,7 +20,6 @@ use gst;
 use gst::subclass::prelude::*;
 
 use BaseParse;
-use BaseParseClass;
 use BaseParseFrame;
 
 pub trait BaseParseImpl: BaseParseImplExt + ElementImpl {
@@ -215,14 +214,14 @@ impl<T: BaseParseImpl> BaseParseImplExt for T {
     }
 }
 
-unsafe impl<T: BaseParseImpl> IsSubclassable<T> for BaseParseClass
+unsafe impl<T: BaseParseImpl> IsSubclassable<T> for BaseParse
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseParseClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseParseClass);
             klass.start = Some(base_parse_start::<T>);
             klass.stop = Some(base_parse_stop::<T>);
             klass.set_sink_caps = Some(base_parse_set_sink_caps::<T>);

gstreamer-base/src/subclass/base_sink.rs

@@ -19,7 +19,6 @@ use gst::subclass::prelude::*;
 use std::ptr;
 
 use BaseSink;
-use BaseSinkClass;
 
 pub trait BaseSinkImpl: BaseSinkImplExt + ElementImpl {
     fn start(&self, element: &BaseSink) -> Result<(), gst::ErrorMessage> {
@@ -381,14 +380,14 @@ impl<T: BaseSinkImpl> BaseSinkImplExt for T {
     }
 }
 
-unsafe impl<T: BaseSinkImpl> IsSubclassable<T> for BaseSinkClass
+unsafe impl<T: BaseSinkImpl> IsSubclassable<T> for BaseSink
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseSinkClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseSinkClass);
             klass.start = Some(base_sink_start::<T>);
             klass.stop = Some(base_sink_stop::<T>);
             klass.render = Some(base_sink_render::<T>);

gstreamer-base/src/subclass/base_src.rs

@@ -20,7 +20,6 @@ use std::mem;
 use std::ptr;
 
 use BaseSrc;
-use BaseSrcClass;
 
 #[derive(Debug)]
 pub enum CreateSuccess {
@@ -570,14 +569,14 @@ impl<T: BaseSrcImpl> BaseSrcImplExt for T {
     }
 }
 
-unsafe impl<T: BaseSrcImpl> IsSubclassable<T> for BaseSrcClass
+unsafe impl<T: BaseSrcImpl> IsSubclassable<T> for BaseSrc
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseSrcClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseSrcClass);
             klass.start = Some(base_src_start::<T>);
             klass.stop = Some(base_src_stop::<T>);
             klass.is_seekable = Some(base_src_is_seekable::<T>);

gstreamer-base/src/subclass/base_transform.rs

@@ -21,7 +21,6 @@ use std::mem;
 use std::ptr;
 
 use BaseTransform;
-use BaseTransformClass;
 
 pub trait BaseTransformImpl: BaseTransformImplExt + ElementImpl {
     fn start(&self, element: &BaseTransform) -> Result<(), gst::ErrorMessage> {
@@ -827,14 +826,14 @@ pub enum BaseTransformMode {
     Both,
 }
 
-unsafe impl<T: BaseTransformImpl> IsSubclassable<T> for BaseTransformClass
+unsafe impl<T: BaseTransformImpl> IsSubclassable<T> for BaseTransform
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstBaseTransformClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstBaseTransformClass);
             klass.start = Some(base_transform_start::<T>);
             klass.stop = Some(base_transform_stop::<T>);
             klass.transform_caps = Some(base_transform_transform_caps::<T>);

gstreamer-base/src/subclass/push_src.rs

@@ -19,7 +19,6 @@ use std::ptr;
 
 use super::base_src::BaseSrcImpl;
 use PushSrc;
-use PushSrcClass;
 
 pub trait PushSrcImpl: PushSrcImplExt + BaseSrcImpl {
     fn fill(
@@ -114,14 +113,14 @@ impl<T: PushSrcImpl> PushSrcImplExt for T {
     }
 }
 
-unsafe impl<T: PushSrcImpl> IsSubclassable<T> for PushSrcClass
+unsafe impl<T: PushSrcImpl> IsSubclassable<T> for PushSrc
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <::BaseSrcClass as IsSubclassable<T>>::override_vfuncs(self);
+        <::BaseSrc as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_base_sys::GstPushSrcClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_base_sys::GstPushSrcClass);
             klass.fill = Some(push_src_fill::<T>);
             klass.alloc = Some(push_src_alloc::<T>);
             klass.create = Some(push_src_create::<T>);

gstreamer-rtsp-server/src/subclass/rtsp_client.rs

@@ -14,7 +14,6 @@ use glib::translate::*;
 use std::mem;
 
 use RTSPClient;
-use RTSPClientClass;
 
 pub trait RTSPClientImpl: RTSPClientImplExt + ObjectImpl + Send + Sync {
     fn create_sdp(&self, client: &RTSPClient, media: &::RTSPMedia) -> Option<gst_sdp::SDPMessage> {
@@ -793,11 +792,11 @@ impl<T: RTSPClientImpl> RTSPClientImplExt for T {
         }
     }
 }
-unsafe impl<T: RTSPClientImpl> IsSubclassable<T> for RTSPClientClass {
+unsafe impl<T: RTSPClientImpl> IsSubclassable<T> for RTSPClient {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPClientClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPClientClass);
             klass.create_sdp = Some(client_create_sdp::<T>);
             klass.configure_client_media = Some(client_configure_client_media::<T>);
             klass.params_set = Some(client_params_set::<T>);

gstreamer-rtsp-server/src/subclass/rtsp_media.rs

@@ -14,7 +14,6 @@ use glib::translate::*;
 use std::ptr;
 
 use RTSPMedia;
-use RTSPMediaClass;
 use RTSPThread;
 
 #[derive(Debug)]
@@ -449,11 +448,11 @@ impl<T: RTSPMediaImpl> RTSPMediaImplExt for T {
         }
     }
 }
-unsafe impl<T: RTSPMediaImpl> IsSubclassable<T> for RTSPMediaClass {
+unsafe impl<T: RTSPMediaImpl> IsSubclassable<T> for RTSPMedia {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPMediaClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPMediaClass);
             klass.handle_message = Some(media_handle_message::<T>);
             klass.prepare = Some(media_prepare::<T>);
             klass.unprepare = Some(media_unprepare::<T>);

gstreamer-rtsp-server/src/subclass/rtsp_media_factory.rs

@@ -14,7 +14,6 @@ use gst_rtsp;
 use glib::subclass::prelude::*;
 
 use RTSPMediaFactory;
-use RTSPMediaFactoryClass;
 
 use std::mem::transmute;
 
@@ -202,12 +201,12 @@ impl<T: RTSPMediaFactoryImpl> RTSPMediaFactoryImplExt for T {
         }
     }
 }
-unsafe impl<T: RTSPMediaFactoryImpl> IsSubclassable<T> for RTSPMediaFactoryClass {
+unsafe impl<T: RTSPMediaFactoryImpl> IsSubclassable<T> for RTSPMediaFactory {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
             let klass =
-                &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPMediaFactoryClass);
+                &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPMediaFactoryClass);
             klass.gen_key = Some(factory_gen_key::<T>);
             klass.create_element = Some(factory_create_element::<T>);
             klass.construct = Some(factory_construct::<T>);

gstreamer-rtsp-server/src/subclass/rtsp_server.rs

@@ -12,7 +12,6 @@ use glib::subclass::prelude::*;
 use glib::translate::*;
 
 use RTSPServer;
-use RTSPServerClass;
 
 pub trait RTSPServerImpl: RTSPServerImplExt + ObjectImpl + Send + Sync {
     fn create_client(&self, server: &RTSPServer) -> Option<::RTSPClient> {
@@ -54,11 +53,11 @@ impl<T: RTSPServerImpl> RTSPServerImplExt for T {
         }
     }
 }
-unsafe impl<T: RTSPServerImpl> IsSubclassable<T> for RTSPServerClass {
+unsafe impl<T: RTSPServerImpl> IsSubclassable<T> for RTSPServer {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_rtsp_server_sys::GstRTSPServerClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_rtsp_server_sys::GstRTSPServerClass);
             klass.create_client = Some(server_create_client::<T>);
             klass.client_connected = Some(server_client_connected::<T>);
         }

gstreamer-video/src/subclass/video_decoder.rs

@@ -22,7 +22,6 @@ use crate::prelude::*;
 use video_codec_state::{Readable, VideoCodecState};
 use VideoCodecFrame;
 use VideoDecoder;
-use VideoDecoderClass;
 
 pub trait VideoDecoderImpl: VideoDecoderImplExt + ElementImpl {
     fn open(&self, element: &VideoDecoder) -> Result<(), gst::ErrorMessage> {
@@ -499,14 +498,14 @@ impl<T: VideoDecoderImpl> VideoDecoderImplExt for T {
     }
 }
 
-unsafe impl<T: VideoDecoderImpl> IsSubclassable<T> for VideoDecoderClass
+unsafe impl<T: VideoDecoderImpl> IsSubclassable<T> for VideoDecoder
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoDecoderClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoDecoderClass);
             klass.open = Some(video_decoder_open::<T>);
             klass.close = Some(video_decoder_close::<T>);
             klass.start = Some(video_decoder_start::<T>);

gstreamer-video/src/subclass/video_encoder.rs

@@ -21,7 +21,6 @@ use crate::prelude::*;
 use video_codec_state::{Readable, VideoCodecState};
 use VideoCodecFrame;
 use VideoEncoder;
-use VideoEncoderClass;
 
 pub trait VideoEncoderImpl: VideoEncoderImplExt + ElementImpl {
     fn open(&self, element: &VideoEncoder) -> Result<(), gst::ErrorMessage> {
@@ -435,14 +434,14 @@ impl<T: VideoEncoderImpl> VideoEncoderImplExt for T {
     }
 }
 
-unsafe impl<T: VideoEncoderImpl> IsSubclassable<T> for VideoEncoderClass
+unsafe impl<T: VideoEncoderImpl> IsSubclassable<T> for VideoEncoder
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoEncoderClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoEncoderClass);
             klass.open = Some(video_encoder_open::<T>);
             klass.close = Some(video_encoder_close::<T>);
             klass.start = Some(video_encoder_start::<T>);

gstreamer-video/src/subclass/video_sink.rs

@@ -17,7 +17,6 @@ use gst::subclass::prelude::*;
 use gst_base::subclass::prelude::*;
 
 use VideoSink;
-use VideoSinkClass;
 
 pub trait VideoSinkImpl: VideoSinkImplExt + BaseSinkImpl + ElementImpl {
     fn show_frame(
@@ -58,14 +57,14 @@ impl<T: VideoSinkImpl> VideoSinkImplExt for T {
     }
 }
 
-unsafe impl<T: VideoSinkImpl> IsSubclassable<T> for VideoSinkClass
+unsafe impl<T: VideoSinkImpl> IsSubclassable<T> for VideoSink
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <gst_base::BaseSinkClass as IsSubclassable<T>>::override_vfuncs(self);
+        <gst_base::BaseSink as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_video_sys::GstVideoSinkClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_video_sys::GstVideoSinkClass);
             klass.show_frame = Some(video_sink_show_frame::<T>);
         }
     }

gstreamer/src/element.rs

@@ -844,8 +844,8 @@ impl<O: IsA<Element>> ElementExtManual for O {
     }
 }
 
-impl ElementClass {
+pub unsafe trait ElementClassExt {
-    pub fn get_metadata<'a>(&self, key: &str) -> Option<&'a str> {
+    fn get_metadata<'a>(&self, key: &str) -> Option<&'a str> {
         unsafe {
             let klass = self as *const _ as *const gst_sys::GstElementClass;
 
@@ -860,7 +860,7 @@ impl ElementClass {
         }
     }
 
-    pub fn get_pad_template(&self, name: &str) -> Option<PadTemplate> {
+    fn get_pad_template(&self, name: &str) -> Option<PadTemplate> {
         unsafe {
             let klass = self as *const _ as *const gst_sys::GstElementClass;
 
@@ -871,7 +871,7 @@ impl ElementClass {
         }
     }
 
-    pub fn get_pad_template_list(&self) -> Vec<PadTemplate> {
+    fn get_pad_template_list(&self) -> Vec<PadTemplate> {
         unsafe {
             let klass = self as *const _ as *const gst_sys::GstElementClass;
 
@@ -882,6 +882,8 @@ impl ElementClass {
     }
 }
 
+unsafe impl<T: IsA<Element>> ElementClassExt for glib::object::Class<T> {}
+
 pub static ELEMENT_METADATA_AUTHOR: Lazy<&'static str> = Lazy::new(|| unsafe {
     CStr::from_ptr(gst_sys::GST_ELEMENT_METADATA_AUTHOR)
         .to_str()

gstreamer/src/lib.rs

@@ -341,7 +341,7 @@ pub mod prelude {
 
     pub use allocator::AllocatorExtManual;
     pub use bin::GstBinExtManual;
-    pub use element::ElementExtManual;
+    pub use element::{ElementClassExt, ElementExtManual};
 
     // OS dependent Bus extensions (also import the other plateform trait for doc)
     #[cfg(any(feature = "v1_14", feature = "dox"))]

gstreamer/src/subclass/bin.rs

@@ -15,7 +15,6 @@ use super::prelude::*;
 use glib::subclass::prelude::*;
 
 use Bin;
-use BinClass;
 use Element;
 use LoggableError;
 use Message;
@@ -87,14 +86,14 @@ impl<T: BinImpl> BinImplExt for T {
     }
 }
 
-unsafe impl<T: BinImpl> IsSubclassable<T> for BinClass
+unsafe impl<T: BinImpl> IsSubclassable<T> for Bin
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <::ElementClass as IsSubclassable<T>>::override_vfuncs(self);
+        <::Element as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstBinClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstBinClass);
             klass.add_element = Some(bin_add_element::<T>);
             klass.remove_element = Some(bin_remove_element::<T>);
             klass.handle_message = Some(bin_handle_message::<T>);

gstreamer/src/subclass/clock.rs

@@ -14,7 +14,6 @@ use glib::subclass::prelude::*;
 use glib::translate::*;
 
 use Clock;
-use ClockClass;
 use ClockError;
 use ClockId;
 use ClockReturn;
@@ -233,12 +232,12 @@ impl<T: ClockImpl> ClockImplExt for T {
     }
 }
 
-unsafe impl<T: ClockImpl> IsSubclassable<T> for ClockClass {
+unsafe impl<T: ClockImpl> IsSubclassable<T> for Clock {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
 
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstClockClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstClockClass);
             klass.change_resolution = Some(clock_change_resolution::<T>);
             klass.get_resolution = Some(clock_get_resolution::<T>);
             klass.get_internal_time = Some(clock_get_internal_time::<T>);

gstreamer/src/subclass/device.rs

@@ -14,7 +14,6 @@ use glib::translate::*;
 use glib::subclass::prelude::*;
 
 use Device;
-use DeviceClass;
 use Element;
 use LoggableError;
 
@@ -99,11 +98,11 @@ impl<T: DeviceImpl> DeviceImplExt for T {
     }
 }
 
-unsafe impl<T: DeviceImpl> IsSubclassable<T> for DeviceClass {
+unsafe impl<T: DeviceImpl> IsSubclassable<T> for Device {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstDeviceClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstDeviceClass);
             klass.create_element = Some(device_create_element::<T>);
             klass.reconfigure_element = Some(device_reconfigure_element::<T>);
         }

gstreamer/src/subclass/device_provider.rs

@@ -114,11 +114,11 @@ pub unsafe trait DeviceProviderClassSubclassExt: Sized + 'static {
 
 unsafe impl DeviceProviderClassSubclassExt for DeviceProviderClass {}
 
-unsafe impl<T: DeviceProviderImpl> IsSubclassable<T> for DeviceProviderClass {
+unsafe impl<T: DeviceProviderImpl> IsSubclassable<T> for DeviceProvider {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstDeviceProviderClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstDeviceProviderClass);
             klass.probe = Some(device_provider_probe::<T>);
             klass.start = Some(device_provider_start::<T>);
             klass.stop = Some(device_provider_stop::<T>);

gstreamer/src/subclass/element.rs

@@ -338,15 +338,15 @@ pub unsafe trait ElementClassSubclassExt: Sized + 'static {
 
 unsafe impl ElementClassSubclassExt for ElementClass {}
 
-unsafe impl<T: ElementImpl> IsSubclassable<T> for ElementClass
+unsafe impl<T: ElementImpl> IsSubclassable<T> for Element
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
 
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstElementClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstElementClass);
             klass.change_state = Some(element_change_state::<T>);
             klass.request_new_pad = Some(element_request_new_pad::<T>);
             klass.release_pad = Some(element_release_pad::<T>);

gstreamer/src/subclass/ghost_pad.rs

@@ -11,15 +11,15 @@ use gst_sys;
 use super::prelude::*;
 use glib::subclass::prelude::*;
 
-use GhostPadClass;
+use GhostPad;
 
 pub trait GhostPadImpl: PadImpl {}
 
-unsafe impl<T: GhostPadImpl> IsSubclassable<T> for GhostPadClass {
+unsafe impl<T: GhostPadImpl> IsSubclassable<T> for GhostPad {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <::PadClass as IsSubclassable<T>>::override_vfuncs(self);
+        <::Pad as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let _klass = &mut *(self as *mut Self as *mut gst_sys::GstGhostPadClass);
+            let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstGhostPadClass);
             // Nothing to do here
         }
     }

gstreamer/src/subclass/pad.rs

@@ -14,7 +14,6 @@ use glib::translate::*;
 use glib::subclass::prelude::*;
 
 use Pad;
-use PadClass;
 
 pub trait PadImpl: PadImplExt + ObjectImpl + Send + Sync {
     fn linked(&self, pad: &Pad, peer: &Pad) {
@@ -58,12 +57,12 @@ impl<T: PadImpl> PadImplExt for T {
     }
 }
 
-unsafe impl<T: PadImpl> IsSubclassable<T> for PadClass {
+unsafe impl<T: PadImpl> IsSubclassable<T> for Pad {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <glib::ObjectClass as IsSubclassable<T>>::override_vfuncs(self);
+        <glib::Object as IsSubclassable<T>>::override_vfuncs(klass);
 
         unsafe {
-            let klass = &mut *(self as *mut Self as *mut gst_sys::GstPadClass);
+            let klass = &mut *(klass.as_mut() as *mut gst_sys::GstPadClass);
             klass.linked = Some(pad_linked::<T>);
             klass.unlinked = Some(pad_unlinked::<T>);
         }

gstreamer/src/subclass/pipeline.rs

@@ -11,18 +11,18 @@ use gst_sys;
 use super::prelude::*;
 use glib::subclass::prelude::*;
 
-use PipelineClass;
+use Pipeline;
 
 pub trait PipelineImpl: BinImpl {}
 
-unsafe impl<T: PipelineImpl> IsSubclassable<T> for PipelineClass
+unsafe impl<T: PipelineImpl> IsSubclassable<T> for Pipeline
 where
     <T as ObjectSubclass>::Instance: PanicPoison,
 {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <::BinClass as IsSubclassable<T>>::override_vfuncs(self);
+        <::Bin as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let _klass = &mut *(self as *mut Self as *mut gst_sys::GstPipelineClass);
+            let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstPipelineClass);
             // Nothing to do here
         }
     }

gstreamer/src/subclass/system_clock.rs

@@ -11,15 +11,15 @@ use gst_sys;
 use super::prelude::*;
 use glib::subclass::prelude::*;
 
-use SystemClockClass;
+use SystemClock;
 
 pub trait SystemClockImpl: ClockImpl {}
 
-unsafe impl<T: SystemClockImpl> IsSubclassable<T> for SystemClockClass {
+unsafe impl<T: SystemClockImpl> IsSubclassable<T> for SystemClock {
-    fn override_vfuncs(&mut self) {
+    fn override_vfuncs(klass: &mut glib::object::Class<Self>) {
-        <::ClockClass as IsSubclassable<T>>::override_vfuncs(self);
+        <::Clock as IsSubclassable<T>>::override_vfuncs(klass);
         unsafe {
-            let _klass = &mut *(self as *mut Self as *mut gst_sys::GstSystemClockClass);
+            let _klass = &mut *(klass.as_mut() as *mut gst_sys::GstSystemClockClass);
             // Nothing to do here
         }
     }