[gstreamermm] MiniObject Classes: Make them opaque reference counted boxed types.

From: José Alburquerque <jaalburqu src gnome org>
To: commits-list gnome org
Cc:
Subject: [gstreamermm] MiniObject Classes: Make them opaque reference counted boxed types.
Date: Fri, 19 Jul 2013 18:33:51 +0000 (UTC)
commit 5d453049e199b680bc00e52cd274fc1537d882f3
Author: José Alburquerque <jaalburquerque gmail com>
Date:   Wed Jul 17 18:55:03 2013 -0400

    MiniObject Classes: Make them opaque reference counted boxed types.
    
        * gstreamer/gstreamermm/wrap.{cc,h}:
        * gstreamer/gstreamermm/gst_wrap_init.h:
        * tools/generate_gst_wrap_init.pl:
        * tools/m4/class_gstminiobject.m4: Delete these files because mini
        object classes are now boxed types.  The gstreamermm wrapping
        subsystem for mini objects, generating gst_wrap_init.cc and the
        _CLASS_GSTMINIOBJECT() macro are no longer needed.
        * gstreamer/gstreamermm/init.cc (initialize_wrap_system): Don't
        use the Gst::wrap_register_init() and Gst::wrap_init() from
        the above delete files because it is no longer necessary.
        * gstreamer/gstreamermm/filelist.am:
        * tools/m4/convert.m4:
        * tools/m4/filelist.am: Also remove the delete files from the build.
        * gstreamer/src/Makefile.am: Don't generate gst_wrap_init.cc.
    
        * gstreamer/src/buffer.{ccg,hg}:
        * gstreamer/src/bufferlist.{ccg,hg}:
        * gstreamer/src/discovererinfo.{ccg,hg}: Make these classes opaque
        reference counted classes removing their custom wrap_new() functions
        and related functions for ensuring that wrappers created are destroyed
        when the C object is destroyed because ensuring that wrappers are
        destroyed for opaque reference counted classes is not necessary.
        * gstreamer/src/event.{ccg,hg}:
        * gstreamer/src/message.{ccg,hg}:
        * gstreamer/src/query.{ccg,hg}: Do the same for these classes and use
        Glib::wrap() instead of Gst::wrap() when needed.  Also remove the
        handwritten virtual function implementations because they are no
        longer part of the C API.
    
        * tools/extra_defs_gen/generate_plugin_gmmproc_file.cc
        (get_signal_wrap_statements): Don't treat mini object types
        differently from boxed types when generating return and parameter
        conversions (which would generate a Gst::wrap() instead of a
        Glib::wrap()) because there is no need to do so.

 gstreamer/gstreamermm/filelist.am                  |    6 +-
 gstreamer/gstreamermm/gst_wrap_init.h              |   36 --
 gstreamer/gstreamermm/init.cc                      |    7 -
 gstreamer/gstreamermm/wrap.cc                      |  212 ------------
 gstreamer/gstreamermm/wrap.h                       |  165 ----------
 gstreamer/src/Makefile.am                          |    6 +-
 gstreamer/src/buffer.ccg                           |   26 --
 gstreamer/src/buffer.hg                            |    6 +-
 gstreamer/src/bufferlist.ccg                       |   19 --
 gstreamer/src/bufferlist.hg                        |    5 +-
 gstreamer/src/discovererinfo.ccg                   |  115 -------
 gstreamer/src/discovererinfo.hg                    |   19 +-
 gstreamer/src/event.ccg                            |  164 +---------
 gstreamer/src/event.hg                             |   46 +---
 gstreamer/src/message.ccg                          |  269 ++--------------
 gstreamer/src/message.hg                           |   39 +---
 gstreamer/src/query.ccg                            |  147 +--------
 gstreamer/src/query.hg                             |   41 +---
 .../extra_defs_gen/generate_plugin_gmmproc_file.cc |   44 ---
 tools/generate_gst_wrap_init.pl                    |  339 --------------------
 tools/m4/class_gstminiobject.m4                    |  289 -----------------
 tools/m4/convert.m4                                |    1 -
 tools/m4/filelist.am                               |    3 +-
 23 files changed, 73 insertions(+), 1931 deletions(-)
---
diff --git a/gstreamer/gstreamermm/filelist.am b/gstreamer/gstreamermm/filelist.am
index a4c7099..cdcb7d6 100644
--- a/gstreamer/gstreamermm/filelist.am
+++ b/gstreamer/gstreamermm/filelist.am
@@ -5,15 +5,11 @@ files_built_h  = $(files_hg:.hg=.h)
 files_built_ph = $(patsubst %.hg,private/%_p.h,$(files_hg))
 files_extra_cc =                \
         init.cc                 \
-        gst_wrap_init.cc        \
         handle_error.cc         \
-        version.cc              \
-        wrap.cc
+        version.cc
 files_extra_h  =                \
         init.h                  \
-        gst_wrap_init.h         \
         handle_error.h          \
         version.h               \
-        wrap.h                  \
         wrap_init.h
 files_extra_ph = 
diff --git a/gstreamer/gstreamermm/init.cc b/gstreamer/gstreamermm/init.cc
index 5db40b2..2c5a73f 100644
--- a/gstreamer/gstreamermm/init.cc
+++ b/gstreamer/gstreamermm/init.cc
@@ -34,11 +34,6 @@ static void initialize_wrap_system()
   {
     //For Glib::wrap(), for Glib::Object-derived classes.
     Gst::wrap_init(); 
-
-    //For Gst::wrap(), for Gst::MiniObject-derived classes.
-    Gst::wrap_register_init();
-    Gst::gst_wrap_init();
-
     s_init = true;
   }
 }
@@ -51,7 +46,6 @@ void init(int& argc, char**& argv)
     Glib::init();
     gst_init(&argc, &argv);
     initialize_wrap_system();
-
     s_init = true;
   }
 }
@@ -64,7 +58,6 @@ void init()
     Glib::init();
     gst_init(0, 0);
     initialize_wrap_system();
-
     s_init = true;
   }
 }
diff --git a/gstreamer/src/Makefile.am b/gstreamer/src/Makefile.am
index b77be86..eaff37b 100644
--- a/gstreamer/src/Makefile.am
+++ b/gstreamer/src/Makefile.am
@@ -21,7 +21,7 @@ include $(srcdir)/filelist.am
 include $(top_srcdir)/tools/m4/filelist.am
 include $(top_srcdir)/build/generate-binding.am
 
-other_built_sources  += $(binding_outputdir)/gst_wrap_init.cc
+other_built_sources  += 
 MAINTAINERCLEANFILES += $(addprefix $(srcdir)/,$(plugins_ccg) $(plugins_hg))
 
 generate_gst_wrap_init = $(codegen_srcdir)/generate_gst_wrap_init.pl
@@ -36,10 +36,6 @@ generate_plugin_dependencies = \
 target_hg_basename = $(basename $(notdir $@))
 target_plugin_and_classname  = $(wordlist 2,3,$(subst |, ,$(filter 
$(target_hg_basename)|%,$(GSTREAMERMM_PLUGIN_DEFS))))
 
-$(binding_outputdir)/gst_wrap_init.cc: $(generate_gst_wrap_init) $(binding_relfiles_hg)
-       $(AM_V_GEN)$(PERL) -- $(generate_gst_wrap_init) $(wrap_init_flags) \
-        $(binding_relfiles_hg) >$@
-
 # This is to generate plugin .ccg files.  The generated .ccg file is piped
 # through m4 using the macros in tools/m4/ctocpp_base.m4 which then produces
 # the final .ccg file.
diff --git a/gstreamer/src/buffer.ccg b/gstreamer/src/buffer.ccg
index e6ea02c..299281b 100644
--- a/gstreamer/src/buffer.ccg
+++ b/gstreamer/src/buffer.ccg
@@ -23,22 +23,6 @@
 
 _PINCLUDE(gstreamermm/private/miniobject_p.h)
 
-namespace
-{
-
-extern "C"
-{
-
-static void Buffer_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::Buffer*>(data);
-}
-
-}
-
-}
-
 namespace Gst
 {
 
@@ -52,14 +36,4 @@ Glib::RefPtr<Gst::Buffer> Buffer::create_writable()
   return Gst::wrap(gst_buffer_make_writable(gobj()));
 }
 
-Gst::MiniObject* Buffer_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::Buffer* wrapper = new Gst::Buffer((GstBuffer*)(object));
-  gst_mini_object_weak_ref(object, &Buffer_gstreamermm_callback_destroy, wrapper);
-  return wrapper;
-}
-
 } // namespace Gst
diff --git a/gstreamer/src/buffer.hg b/gstreamer/src/buffer.hg
index a1bc2e4..b4f90c6 100644
--- a/gstreamer/src/buffer.hg
+++ b/gstreamer/src/buffer.hg
@@ -19,7 +19,6 @@
 
 #include <gst/gstbuffer.h>
 #include <gstreamermm/miniobject.h>
-#include <gstreamermm/wrap.h>
 #include <gstreamermm/caps.h>
 
 _DEFS(gstreamermm,gst)
@@ -44,11 +43,10 @@ _WRAP_ENUM(BufferCopyFlags, GstBufferCopyFlags)
  */
 class Buffer : public MiniObject
 {
-  _CLASS_GSTMINIOBJECT(Buffer, GstBuffer, GST_BUFFER, Gst::MiniObject, GstMiniObject)
-  _CUSTOM_WRAP_NEW
+  _CLASS_OPAQUE_REFCOUNTED(Buffer, GstBuffer, gst_buffer_new, gst_buffer_ref, gst_buffer_unref)
+  _IGNORE(gst_buffer_ref, gst_buffer_unref)
 
 public:
-  _WRAP_METHOD(static Glib::RefPtr<Gst::Buffer> create(), gst_buffer_new)
   _WRAP_METHOD(static Glib::RefPtr<Gst::Buffer> create(guint size), gst_buffer_try_new_and_alloc)
 
   /** Create a copy of the given buffer. This will also make a newly allocated
diff --git a/gstreamer/src/bufferlist.ccg b/gstreamer/src/bufferlist.ccg
index c414794..64f0f07 100644
--- a/gstreamer/src/bufferlist.ccg
+++ b/gstreamer/src/bufferlist.ccg
@@ -86,12 +86,6 @@ static GstBuffer* BufferListIterator_Process_gstreamermm_callback(GstBuffer* buf
   return 0;
 }
 
-static void BufferList_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::BufferList*>(data);
-}
-
 } // extern "C"
 
 
@@ -124,19 +118,6 @@ void BufferList::iterate(BufferListIterator& result)
   result.set_gobject(gst_buffer_list_iterate(gobj()));
 }
 
-Gst::MiniObject* BufferList_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::BufferList* wrapper = new Gst::BufferList((GstBufferList*)(object));
-
-  gst_mini_object_weak_ref(object, &BufferList_gstreamermm_callback_destroy,
-    wrapper);
-
-  return wrapper;
-}
-
 BufferListIterator::BufferListIterator()
 : gobject_(0),
   take_ownership(false)
diff --git a/gstreamer/src/bufferlist.hg b/gstreamer/src/bufferlist.hg
index 5da389b..1262cb6 100644
--- a/gstreamer/src/bufferlist.hg
+++ b/gstreamer/src/bufferlist.hg
@@ -19,7 +19,6 @@
 
 #include <gst/gstbufferlist.h>
 #include <gstreamermm/miniobject.h>
-#include <gstreamermm/wrap.h>
 
 _DEFS(gstreamermm,gst)
 
@@ -49,8 +48,8 @@ class BufferListIterator;
  */
 class BufferList : public MiniObject
 {
-  _CLASS_GSTMINIOBJECT(BufferList, GstBufferList, GST_BUFFER_LIST, Gst::MiniObject, GstMiniObject)
-  _CUSTOM_WRAP_NEW
+  _CLASS_OPAQUE_REFCOUNTED(BufferList, GstBufferList, gst_buffer_list_new, gst_buffer_list_ref, 
gst_buffer_list_unref)
+  _IGNORE(gst_buffer_list_ref, gst_buffer_list_unref)
 
 public:
   /** For example,
diff --git a/gstreamer/src/discovererinfo.ccg b/gstreamer/src/discovererinfo.ccg
index ef29e1b..61f0eea 100644
--- a/gstreamer/src/discovererinfo.ccg
+++ b/gstreamer/src/discovererinfo.ccg
@@ -23,118 +23,3 @@
 #include <gstreamermm/taglist.h>
 
 _PINCLUDE(gstreamermm/private/miniobject_p.h)
-
-namespace
-{
-
-extern "C"
-{
-
-static void DiscovererInfo_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::DiscovererInfo*>(data);
-}
-
-static void DiscovererStreamInfo_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::DiscovererStreamInfo*>(data);
-}
-
-static void DiscovererContainerInfo_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::DiscovererContainerInfo*>(data);
-}
-
-static void DiscovererAudioInfo_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::DiscovererAudioInfo*>(data);
-}
-
-static void DiscovererVideoInfo_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  delete static_cast<Gst::DiscovererVideoInfo*>(data);
-}
-
-}
-
-}
-
-namespace Gst
-{
-
-Gst::MiniObject* DiscovererInfo_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::DiscovererInfo* wrapper =
-    new Gst::DiscovererInfo((GstDiscovererInfo*)(object));
-
-  gst_mini_object_weak_ref(object,
-    &DiscovererInfo_gstreamermm_callback_destroy, wrapper);
-
-  return wrapper;
-}
-
-Gst::MiniObject* DiscovererStreamInfo_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::DiscovererStreamInfo* wrapper =
-    new Gst::DiscovererStreamInfo((GstDiscovererStreamInfo*)(object));
-
-  gst_mini_object_weak_ref(object,
-    &DiscovererStreamInfo_gstreamermm_callback_destroy, wrapper);
-
-  return wrapper;
-}
-
-Gst::MiniObject* DiscovererContainerInfo_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::DiscovererContainerInfo* wrapper =
-    new Gst::DiscovererContainerInfo((GstDiscovererContainerInfo*)(object));
-
-  gst_mini_object_weak_ref(object,
-    &DiscovererContainerInfo_gstreamermm_callback_destroy, wrapper);
-
-  return wrapper;
-}
-
-Gst::MiniObject* DiscovererAudioInfo_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::DiscovererAudioInfo* wrapper =
-    new Gst::DiscovererAudioInfo((GstDiscovererAudioInfo*)(object));
-
-  gst_mini_object_weak_ref(object,
-    &DiscovererAudioInfo_gstreamermm_callback_destroy, wrapper);
-
-  return wrapper;
-}
-
-Gst::MiniObject* DiscovererVideoInfo_Class::wrap_new(GstMiniObject* object)
-{
-  // Use this wrap_new() method to ensure that the wrapper is destroyed
-  // when the miniobject loses its last reference.
-
-  Gst::DiscovererVideoInfo* wrapper =
-    new Gst::DiscovererVideoInfo((GstDiscovererVideoInfo*)(object));
-
-  gst_mini_object_weak_ref(object,
-    &DiscovererVideoInfo_gstreamermm_callback_destroy, wrapper);
-
-  return wrapper;
-}
-
-} // namespace Gst
diff --git a/gstreamer/src/discovererinfo.hg b/gstreamer/src/discovererinfo.hg
index 2d20334..263b00a 100644
--- a/gstreamer/src/discovererinfo.hg
+++ b/gstreamer/src/discovererinfo.hg
@@ -62,10 +62,9 @@ class TagList;
  */
 class DiscovererInfo : public MiniObject
 {
-  _STRUCT_NOT_HIDDEN
-  _CLASS_GSTMINIOBJECT(DiscovererInfo, GstDiscovererInfo, GST_DISCOVERER_INFO, MiniObject, GstMiniObject)
+  _CLASS_OPAQUE_REFCOUNTED(DiscovererInfo, GstDiscovererInfo, gst_discoverer_info_new, 
gst_discoverer_info_ref, gst_discoverer_info_unref)
   _IGNORE(gst_discoverer_info_ref, gst_discoverer_info_unref)
-  _CUSTOM_WRAP_NEW
+  _STRUCT_NOT_HIDDEN
 
 public:
   _WRAP_METHOD(ClockTime get_duration() const, gst_discoverer_info_get_duration) 
@@ -122,10 +121,9 @@ public:
  */
 class DiscovererStreamInfo : public MiniObject
 {
-  _STRUCT_NOT_HIDDEN
-  _CLASS_GSTMINIOBJECT(DiscovererStreamInfo, GstDiscovererStreamInfo, GST_DISCOVERER_STREAM_INFO, 
MiniObject, GstMiniObject)
+  _CLASS_OPAQUE_REFCOUNTED(DiscovererStreamInfo, GstDiscovererStreamInfo, NONE, 
gst_discoverer_stream_info_ref, gst_discoverer_stream_info_unref)
   _IGNORE(gst_discoverer_stream_info_ref, gst_discoverer_stream_info_unref)
-  _CUSTOM_WRAP_NEW
+  _STRUCT_NOT_HIDDEN
 
 public:
   _WRAP_METHOD(Glib::RefPtr<Gst::Caps> get_caps(), gst_discoverer_stream_info_get_caps)
@@ -149,9 +147,8 @@ public:
  */
 class DiscovererContainerInfo : public DiscovererStreamInfo
 {
+  _CLASS_OPAQUE_REFCOUNTED(DiscovererContainerInfo, GstDiscovererContainerInfo, NONE, 
gst_discoverer_stream_info_ref, gst_discoverer_stream_info_unref)
   _STRUCT_NOT_HIDDEN
-  _CLASS_GSTMINIOBJECT(DiscovererContainerInfo, GstDiscovererContainerInfo, GST_DISCOVERER_CONTAINER_INFO, 
DiscovererStreamInfo, GstDiscovererStreamInfo)
-  _CUSTOM_WRAP_NEW
 
 public:
   _WRAP_METHOD(std::vector< Glib::RefPtr<DiscovererStreamInfo> > get_streams(), 
gst_discoverer_container_info_get_streams)
@@ -163,9 +160,8 @@ public:
  */
 class DiscovererAudioInfo : public DiscovererStreamInfo
 {
+  _CLASS_OPAQUE_REFCOUNTED(DiscovererAudioInfo, GstDiscovererAudioInfo, NONE, 
gst_discoverer_stream_info_ref, gst_discoverer_stream_info_unref)
   _STRUCT_NOT_HIDDEN
-  _CLASS_GSTMINIOBJECT(DiscovererAudioInfo, GstDiscovererAudioInfo, GST_DISCOVERER_AUDIO_INFO, 
DiscovererStreamInfo, GstDiscovererStreamInfo)
-  _CUSTOM_WRAP_NEW
 
 public:
   _WRAP_METHOD(guint get_bitrate() const, gst_discoverer_audio_info_get_bitrate)
@@ -180,9 +176,8 @@ public:
  */
 class DiscovererVideoInfo : public DiscovererStreamInfo
 {
+  _CLASS_OPAQUE_REFCOUNTED(DiscovererVideoInfo, GstDiscovererVideoInfo, NONE, 
gst_discoverer_stream_info_ref, gst_discoverer_stream_info_unref)
   _STRUCT_NOT_HIDDEN
-  _CLASS_GSTMINIOBJECT(DiscovererVideoInfo, GstDiscovererVideoInfo, GST_DISCOVERER_VIDEO_INFO, 
DiscovererStreamInfo, GstDiscovererStreamInfo)
-  _CUSTOM_WRAP_NEW
 
 public:
   _WRAP_METHOD(guint get_bitrate() const, gst_discoverer_video_info_get_bitrate)
diff --git a/gstreamer/src/event.ccg b/gstreamer/src/event.ccg
index 9363424..429cfa2 100644
--- a/gstreamer/src/event.ccg
+++ b/gstreamer/src/event.ccg
@@ -25,24 +25,6 @@
 _PINCLUDE(gstreamermm/private/miniobject_p.h)
 #include <iostream>
 
-namespace
-{
-
-extern "C"
-{
-
-static void Event_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  // This works for any of the Gst::Event derived classes because none of
-  // them have member variables so in essence they are all the same size.
-  delete static_cast<Gst::Event*>(data);
-}
-
-}
-
-}
-
 namespace Gst
 {
 
@@ -69,7 +51,7 @@ EventTypeFlags get_flags(EventType t)
 Glib::RefPtr<Gst::Event> Event::create_writable()
 {
   return
-   Gst::wrap(GST_EVENT(gst_mini_object_make_writable(GST_MINI_OBJECT(gobj()))));
+   Glib::wrap(GST_EVENT(gst_mini_object_make_writable(GST_MINI_OBJECT(gobj()))));
 }
 
 bool Event::is_downstream() const
@@ -94,7 +76,7 @@ Event(castitem)
 Glib::RefPtr<Gst::EventFlushStart> EventFlushStart::create()
 {
   GstEvent* event = gst_event_new_flush_start();
-  return Gst::Event::wrap<EventFlushStart>(event, false);
+  return Glib::wrap(event, false);
 }
 
 EventFlushStop::EventFlushStop(GstEvent* castitem) :
@@ -104,7 +86,7 @@ Event(castitem)
 Glib::RefPtr<Gst::EventFlushStop> EventFlushStop::create()
 {
   GstEvent* event = gst_event_new_flush_stop();
-  return Gst::Event::wrap<EventFlushStop>(event, false);
+  return Glib::wrap(event, false);
 }
 
 EventEos::EventEos(GstEvent* castitem) :
@@ -114,7 +96,7 @@ Event(castitem)
 Glib::RefPtr<Gst::EventEos> EventEos::create()
 {
   GstEvent* event = gst_event_new_eos();
-  return Gst::Event::wrap<EventEos>(event, false);
+  return Glib::wrap(event, false);
 }
 
 EventNewSegment::EventNewSegment(GstEvent* castitem) :
@@ -127,7 +109,7 @@ Glib::RefPtr<Gst::EventNewSegment>
 {
   GstEvent* event = gst_event_new_new_segment_full(update, rate, applied_rate,
     GstFormat(format), start, stop, position);
-  return Gst::Event::wrap<EventNewSegment>(event, false);
+  return Glib::wrap(event, false);
 }
 
 void EventNewSegment::parse(bool& update, double& rate, Format& format,
@@ -197,7 +179,7 @@ Glib::RefPtr<Gst::EventTag> EventTag::create(const Gst::TagList& taglist)
   //We create a copy because gst_event_new_tag() takes ownership:
   GstTagList* c_taglist = gst_tag_list_copy(taglist.gobj());
   GstEvent* event = gst_event_new_tag(c_taglist);
-  return Gst::Event::wrap<EventTag>(event, false);
+  return Glib::wrap(event, false);
 }
 
 Gst::TagList EventTag::parse() const
@@ -217,7 +199,7 @@ Glib::RefPtr<Gst::EventBufferSize>
 {
   GstEvent* event = gst_event_new_buffer_size(GstFormat(format), minsize,
     maxsize, async);
-  return Gst::Event::wrap<EventBufferSize>(event, false);
+  return Glib::wrap(event, false);
 }
 
 void EventBufferSize::parse(Format& format, gint64& minsize, gint64& maxsize,
@@ -269,7 +251,7 @@ Glib::RefPtr<Gst::EventQos> EventQos::create(double proportion,
 {
   GstEvent* event = gst_event_new_qos(proportion, GstClockTimeDiff(diff),
     GstClockTime(timestamp));
-  return Gst::Event::wrap<EventQos>(event, false);
+  return Glib::wrap(event, false);
 }
 
 void EventQos::parse(double& proportion, ClockTimeDiff& diff,
@@ -312,7 +294,7 @@ Glib::RefPtr<Gst::EventSeek> EventSeek::create(double rate, Format format,
     GstSeekFlags(flags), GstSeekType(start_type), start,
     GstSeekType(stop_type), stop);
 
-  return Gst::Event::wrap<EventSeek>(event, false);
+  return Glib::wrap(event, false);
 }
 
 void EventSeek::parse(double& rate, Format& format, SeekFlags& flags,
@@ -389,7 +371,7 @@ Glib::RefPtr<Gst::EventNavigation>
   // Make copy because event takes ownership of structure:
   GstStructure* copy = gst_structure_copy(structure.gobj());
   GstEvent* event = gst_event_new_navigation(copy);
-  return Gst::Event::wrap<EventNavigation>(event, false);
+  return Glib::wrap(event, false);
 }
 
 EventLatency::EventLatency(GstEvent* castitem) :
@@ -399,7 +381,7 @@ Event(castitem)
 Glib::RefPtr<Gst::EventLatency> EventLatency::create(ClockTime time)
 {
   GstEvent* event = gst_event_new_latency(GstClockTime(time));
-  return Gst::Event::wrap<EventLatency>(event, false);
+  return Glib::wrap(event, false);
 }
 
 ClockTime EventLatency::parse() const
@@ -419,7 +401,7 @@ Glib::RefPtr<Gst::EventStep>
 {
   GstEvent* event = gst_event_new_step(static_cast<GstFormat>(format),
     amount, rate, flush, intermediate);
-  return Gst::Event::wrap<EventStep>(event, false);
+  return Glib::wrap(event, false);
 }
 
 void EventStep::parse(Gst::Format& format, guint64& amount, double& rate,
@@ -480,137 +462,21 @@ Glib::RefPtr<Gst::EventSinkMessage>
   EventSinkMessage::create(const Glib::RefPtr<Gst::Message>& msg)
 {
   GstEvent* event = gst_event_new_sink_message(msg->gobj());
-  return Gst::Event::wrap<EventSinkMessage>(event, false);
+  return Glib::wrap(event, false);
 }
 
 Glib::RefPtr<Gst::Message> EventSinkMessage::parse()
 {
   GstMessage* gst_msg = 0;
   gst_event_parse_sink_message(gobj(), &gst_msg);
-  return Gst::wrap(gst_msg);
+  return Glib::wrap(gst_msg);
 }
 
 Glib::RefPtr<const Gst::Message> EventSinkMessage::parse() const
 {
   GstMessage* gst_msg = 0;
   gst_event_parse_sink_message(const_cast<GstEvent*>(gobj()), &gst_msg);
-  return Gst::wrap(gst_msg);
-}
-
-Glib::RefPtr<Gst::Event> Event::wrap(GstEvent* event, bool take_copy)
-{
-  Gst::Event* wrapper = 0;
-  Glib::RefPtr<Gst::Event> result;
-
-  if(!event)
-    return result;
-
-  switch(GST_EVENT_TYPE(event))
-  {
-    case GST_EVENT_FLUSH_START:
-      wrapper = new Gst::EventFlushStart(event);
-      break;
-    case GST_EVENT_FLUSH_STOP:
-      wrapper = new Gst::EventFlushStop(event);
-      break;
-    case GST_EVENT_EOS:
-      wrapper = new Gst::EventEos(event);
-      break;
-    case GST_EVENT_NEWSEGMENT:
-      wrapper = new Gst::EventNewSegment(event);
-      break;
-    case GST_EVENT_TAG:
-      wrapper = new Gst::EventTag(event);
-      break;
-    case GST_EVENT_BUFFERSIZE:
-      wrapper = new Gst::EventBufferSize(event);
-      break;
-    case GST_EVENT_SINK_MESSAGE:
-      wrapper = new Gst::EventSinkMessage(event);
-      break;
-    case GST_EVENT_QOS:
-      wrapper = new Gst::EventQos(event);
-      break;
-    case GST_EVENT_SEEK:
-      wrapper = new Gst::EventSeek(event);
-      break;
-    case GST_EVENT_NAVIGATION:
-      wrapper = new Gst::EventNavigation(event);
-      break;
-    case GST_EVENT_LATENCY:
-      wrapper = new Gst::EventLatency(event);
-      break;
-    case GST_EVENT_STEP:
-      wrapper = new Gst::EventStep(event);
-      break;
-    default:
-      wrapper = new Gst::Event(event);
-  }
-
-  result = Glib::RefPtr<Gst::Event>(wrapper);
-
-  // Ensure that the wrapper is freed when the event (mini object) is freed.
-  gst_mini_object_weak_ref(GST_MINI_OBJECT(event), &Event_gstreamermm_callback_destroy, wrapper);
-
-  if(take_copy)
-    result->reference();
-
-  return result;
-}
-
-Gst::MiniObject* Event_Class::wrap_new(GstMiniObject* object)
-{
-  // Use the Gst::Event wrap() method to get the right type of Event class
-  // and return the underlying object in the refptr.  The extra reference is
-  // needed so that the object does not loose a reference when the local refptr
-  // is destroyed.
-  return Gst::Event::wrap((GstEvent*)object, true).operator->();
-}
-
-GstMiniObject* Event_Class::copy_vfunc_callback(const GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-    return (*GST_MINI_OBJECT_CLASS(base)->copy)(self);
-
-  return 0;
-}
-Glib::RefPtr<Gst::MiniObject> Event::copy_vfunc() const
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-  {
-    return Gst::Event::wrap(GST_EVENT((*GST_MINI_OBJECT_CLASS(base)->copy)(
-        GST_MINI_OBJECT(gobj()))));
-  }
-
-  return Glib::RefPtr<Gst::MiniObject>(0);
-}
-void Event_Class::finalize_vfunc_callback(GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(self);
-}
-void Event::finalize_vfunc()
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(GST_MINI_OBJECT(gobj()));
+  return Glib::wrap(gst_msg);
 }
 
 } //namespace Gst
diff --git a/gstreamer/src/event.hg b/gstreamer/src/event.hg
index 19b96f3..f094377 100644
--- a/gstreamer/src/event.hg
+++ b/gstreamer/src/event.hg
@@ -19,7 +19,6 @@
 
 #include <gst/gstevent.h>
 #include <gstreamermm/miniobject.h>
-#include <gstreamermm/wrap.h>
 #include <gstreamermm/format.h>
 #include <gstreamermm/clock.h>
 
@@ -129,18 +128,10 @@ EventTypeFlags get_flags(EventType type);
  */
 class Event : public MiniObject
 {
-  _CLASS_GSTMINIOBJECT(Event, GstEvent, GST_EVENT, Gst::MiniObject, GstMiniObject)
+  _CLASS_OPAQUE_REFCOUNTED(Event, GstEvent, NONE, gst_event_ref, gst_event_unref)
   _IGNORE(gst_event_ref, gst_event_unref)
-  _CUSTOM_WRAP_NEW
 
 public:
-  /** Wrap a GstEvent in a C++ instance, creating an instance of a derived
-   * Gst::Event. Gst::wrap() would just create a Gst::Event (rather than a
-   * derived one) because the derived Gst::Event classes do not correspond
-   * to GType types in the GStreamer API.
-   */
-  static Glib::RefPtr<Gst::Event> wrap(GstEvent* event, bool take_copy = false);
-
 // A copy is taken so that the original is not freed by the wrapper.
 #m4 _CONVERSION(`const GstStructure*',`Gst::Structure',`Glib::wrap(const_cast<GstStructure*>($3), true)')
   _WRAP_METHOD(Gst::Structure get_structure() const, gst_event_get_structure)
@@ -180,32 +171,6 @@ public:
   /** The source Gst::Object that generated this event.
    */
   _MEMBER_GET_GOBJECT(source, src, Gst::Object, GstObject*)
-
-  /** Virtual function called when the Gst::Event needs to be copied.
-   */
-  virtual Glib::RefPtr<Gst::MiniObject> copy_vfunc() const;
-
-  /** Virtual function called when the Gst::Event is about to be finalized.
-   */
-  virtual void finalize_vfunc();
-
-protected:
-#m4begin
-  _PUSH(SECTION_PCC_CLASS_INIT_VFUNCS)
-  GST_MINI_OBJECT_CLASS(klass)->copy = &copy_vfunc_callback;
-  GST_MINI_OBJECT_CLASS(klass)->finalize = &finalize_vfunc_callback;
-  _SECTION(SECTION_PH_VFUNCS)
-  static GstMiniObject* copy_vfunc_callback(const GstMiniObject* self);
-  static void finalize_vfunc_callback(GstMiniObject* self);
-  _POP()
-#m4end
-
-protected:
-  // This method is used in the create() methods to convert a wrapped GstEvent
-  // to one of the more specific Gst::Event types.
-  template <class EventType>
-    static inline Glib::RefPtr<EventType> wrap(GstEvent* event,
-    bool take_copy = false);
 };
 
 //TODO: Modify create methods of derived Event classes to return
@@ -837,13 +802,4 @@ public:
   Glib::RefPtr<const Gst::Message> parse() const;
 };
 
-/****************************** Gst::Event **************************/
-
-template <class EventType>
-  Glib::RefPtr<EventType> Event::wrap(GstEvent* event, bool take_copy)
-{
-  Glib::RefPtr<Gst::Event> result = wrap(event, take_copy);
-  return Glib::RefPtr<EventType>::cast_dynamic(result);
-}
-
 } //namespace Gst
diff --git a/gstreamer/src/message.ccg b/gstreamer/src/message.ccg
index 486fba6..fe5dee1 100644
--- a/gstreamer/src/message.ccg
+++ b/gstreamer/src/message.ccg
@@ -27,24 +27,6 @@
 _PINCLUDE(gstreamermm/private/miniobject_p.h)
 #include <iostream>
 
-namespace
-{
-
-extern "C"
-{
-
-static void Message_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  // This works for any of the Gst::Message derived classes because none of
-  // them have member variables so in essence they are all the same size.
-  delete static_cast<Gst::Message*>(data);
-}
-
-}
-
-}
-
 namespace Gst
 {
 
@@ -65,7 +47,7 @@ Glib::QueryQuark get_quark(MessageType t)
 
 Glib::RefPtr<Gst::Message> Message::create_writable()
 {
-  return wrap(gst_message_make_writable(gobj()));
+  return Glib::wrap(gst_message_make_writable(gobj()));
 }
 
 MessageEos::MessageEos(GstMessage* castitem)
@@ -76,7 +58,7 @@ Glib::RefPtr<Gst::MessageEos>
   MessageEos::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_eos(Glib::unwrap(src));
-  return Gst::Message::wrap<MessageEos>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageError::MessageError(GstMessage* castitem)
@@ -89,7 +71,7 @@ Glib::RefPtr<Gst::MessageError>
 {
   GstMessage* message = gst_message_new_error(Glib::unwrap(src), error.gobj(),
     reinterpret_cast<const gchar*>(debug.c_str()));
-  return Gst::Message::wrap<MessageError>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageError::parse(Glib::Error& error, std::string& debug) const
@@ -141,7 +123,7 @@ Glib::RefPtr<Gst::MessageWarning>
 {
   GstMessage* message = gst_message_new_warning(Glib::unwrap(src),
     error.gobj(), reinterpret_cast<const gchar*>(debug.c_str()));
-  return Gst::Message::wrap<MessageWarning>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageWarning::parse(Glib::Error& error, std::string& debug) const
@@ -194,7 +176,7 @@ Glib::RefPtr<Gst::MessageInfo>
 {
   GstMessage* message = gst_message_new_info(Glib::unwrap(src), error.gobj(),
     reinterpret_cast<const gchar*>(debug.c_str()));
-  return Gst::Message::wrap<MessageInfo>(message, false);
+  return Glib::wrap(message, false);
 }
 
 
@@ -248,7 +230,7 @@ Glib::RefPtr<Gst::MessageTag>
   //We create a copy because gst_message_new_tag() takes ownership:
   GstTagList* c_taglist = gst_tag_list_copy(taglist.gobj());
   GstMessage* message = gst_message_new_tag(Glib::unwrap(src), c_taglist);
-  return Gst::Message::wrap<MessageTag>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::MessageTag>
@@ -259,7 +241,7 @@ Glib::RefPtr<Gst::MessageTag>
   GstTagList* c_taglist = gst_tag_list_copy(taglist.gobj());
   GstMessage* message = gst_message_new_tag_full(Glib::unwrap(src),
     Glib::unwrap(pad), c_taglist);
-  return Gst::Message::wrap<MessageTag>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageTag::parse(Glib::RefPtr<Gst::Pad>& pad, Gst::TagList& tag_list)
@@ -299,7 +281,7 @@ Glib::RefPtr<Gst::MessageBuffering>
   MessageBuffering::create(const Glib::RefPtr<Gst::Object>& src, int percent)
 {
   GstMessage* message = gst_message_new_buffering(Glib::unwrap(src), percent);
-  return Gst::Message::wrap<MessageBuffering>(message, false);
+  return Glib::wrap(message, false);
 }
 
 int MessageBuffering::parse() const
@@ -371,7 +353,7 @@ Glib::RefPtr<Gst::MessageStateChanged>
   GstMessage* message = gst_message_new_state_changed(Glib::unwrap(src),
     static_cast<GstState>(oldstate), static_cast<GstState>(newstate),
     static_cast<GstState>(pending));
-  return Gst::Message::wrap<MessageStateChanged>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageStateChanged::parse(State& oldstate, State& newstate,
@@ -417,7 +399,7 @@ Glib::RefPtr<Gst::MessageStateDirty>
   MessageStateDirty::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_state_dirty(Glib::unwrap(src));
-  return Gst::Message::wrap<MessageStateDirty>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageStepDone::MessageStepDone(GstMessage* castitem)
@@ -432,7 +414,7 @@ Glib::RefPtr<Gst::MessageStepDone>
   GstMessage* message = gst_message_new_step_done(Glib::unwrap(src),
     static_cast<GstFormat>(format), amount, rate, flush, intermediate,
     duration, eos);
-  return Gst::Message::wrap<MessageStepDone>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageStepDone::parse(Gst::Format& format, guint64& amount, double& rate,
@@ -518,7 +500,7 @@ Glib::RefPtr<Gst::MessageClockProvide>
 {
   GstMessage* message = gst_message_new_clock_provide(Glib::unwrap(src),
     Glib::unwrap(clock), ready);
-  return Gst::Message::wrap<MessageClockProvide>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageClockProvide::parse(Glib::RefPtr<Gst::Clock>& clock, bool& ready) const
@@ -561,7 +543,7 @@ Glib::RefPtr<Gst::MessageClockLost>
 {
   GstMessage* message = gst_message_new_clock_lost(Glib::unwrap(src),
     Glib::unwrap(clock));
-  return Gst::Message::wrap<MessageClockLost>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::Clock> MessageClockLost::parse()
@@ -586,7 +568,7 @@ Glib::RefPtr<Gst::MessageNewClock>
 {
   GstMessage* message = gst_message_new_new_clock(Glib::unwrap(src),
     Glib::unwrap(clock));
-  return Gst::Message::wrap<MessageNewClock>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::Clock> MessageNewClock::parse()
@@ -612,14 +594,14 @@ Glib::RefPtr<Gst::MessageApplication>
   GstStructure* copy_struct = gst_structure_copy(structure.gobj());
   GstMessage* message = gst_message_new_application(Glib::unwrap(src),
     copy_struct);
-  return Gst::Message::wrap<MessageApplication>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::MessageApplication>
   MessageApplication::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_application(Glib::unwrap(src), 0);
-  return Gst::Message::wrap<MessageApplication>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageElement::MessageElement(GstMessage* castitem)
@@ -633,14 +615,14 @@ Glib::RefPtr<Gst::MessageElement>
   GstStructure* copy_struct = gst_structure_copy(structure.gobj());
   GstMessage* message = gst_message_new_element(Glib::unwrap(src),
     copy_struct);
-  return Gst::Message::wrap<MessageElement>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::MessageElement>
   MessageElement::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_element(Glib::unwrap(src), 0);
-  return Gst::Message::wrap<MessageElement>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageCustom::MessageCustom(GstMessage* castitem)
@@ -654,7 +636,7 @@ Glib::RefPtr<Gst::MessageCustom>
   GstStructure* copy_struct = gst_structure_copy(structure.gobj());
   GstMessage* message = gst_message_new_custom(GstMessageType(type),
     Glib::unwrap(src), copy_struct);
-  return Gst::Message::wrap<MessageCustom>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Glib::RefPtr<Gst::MessageCustom>
@@ -662,7 +644,7 @@ Glib::RefPtr<Gst::MessageCustom>
 {
   GstMessage* message = gst_message_new_custom(GstMessageType(type),
     Glib::unwrap(src), 0);
-  return Gst::Message::wrap<MessageCustom>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageSegmentStart::MessageSegmentStart(GstMessage* castitem)
@@ -675,7 +657,7 @@ Glib::RefPtr<Gst::MessageSegmentStart>
 {
   GstMessage* message = gst_message_new_segment_start(Glib::unwrap(src),
     static_cast<GstFormat>(format), position);
-  return Gst::Message::wrap<MessageSegmentStart>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageSegmentStart::parse(Format& format, gint64& position) const
@@ -710,7 +692,7 @@ Glib::RefPtr<Gst::MessageSegmentDone>
 {
   GstMessage* message = gst_message_new_segment_done(Glib::unwrap(src),
     static_cast<GstFormat>(format), position);
-  return Gst::Message::wrap<MessageSegmentDone>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageSegmentDone::parse(Format& format, gint64& position) const
@@ -745,7 +727,7 @@ Glib::RefPtr<Gst::MessageDuration>
 {
   GstMessage* message = gst_message_new_duration(Glib::unwrap(src),
     static_cast<GstFormat>(format), duration);
-  return Gst::Message::wrap<MessageDuration>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageDuration::parse(Format& format, gint64& duration) const
@@ -777,7 +759,7 @@ Glib::RefPtr<Gst::MessageLatency>
   MessageLatency::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_latency(Glib::unwrap(src));
-  return Gst::Message::wrap<MessageLatency>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageAsyncStart::MessageAsyncStart(GstMessage* castitem)
@@ -790,7 +772,7 @@ Glib::RefPtr<Gst::MessageAsyncStart>
 {
   GstMessage* message = gst_message_new_async_start(Glib::unwrap(src),
     new_base_time);
-  return Gst::Message::wrap<MessageAsyncStart>(message, false);
+  return Glib::wrap(message, false);
 }
 
 bool MessageAsyncStart::parse() const
@@ -809,7 +791,7 @@ Glib::RefPtr<Gst::MessageAsyncDone>
   MessageAsyncDone::create(const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_async_done(Glib::unwrap(src));
-  return Gst::Message::wrap<MessageAsyncDone>(message, false);
+  return Glib::wrap(message, false);
 }
 
 MessageStepStart::MessageStepStart(GstMessage* castitem)
@@ -823,7 +805,7 @@ Glib::RefPtr<Gst::MessageStepStart>
 {
   GstMessage* message = gst_message_new_step_start(Glib::unwrap(src),
     active, static_cast<GstFormat>(format), amount, rate, flush, intermediate);
-  return Gst::Message::wrap<MessageStepStart>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageStepStart::parse(bool& active, Gst::Format& format,
@@ -901,7 +883,7 @@ Glib::RefPtr<Gst::MessageStructureChange>
 {
   GstMessage* message = gst_message_new_structure_change(Glib::unwrap(src),
     static_cast<GstStructureChangeType>(type), Glib::unwrap(owner), busy);
-  return Gst::Message::wrap<MessageStructureChange>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageStructureChange::parse(Gst::StructureChangeType& type,
@@ -949,7 +931,7 @@ Glib::RefPtr<Gst::MessageRequestState>
 {
   GstMessage* message = gst_message_new_request_state(Glib::unwrap(src),
     static_cast<GstState>(state));
-  return Gst::Message::wrap<MessageRequestState>(message, false);
+  return Glib::wrap(message, false);
 }
 
 Gst::State MessageRequestState::parse() const
@@ -970,7 +952,7 @@ Glib::RefPtr<Gst::MessageStreamStatus>
 {
   GstMessage* message = gst_message_new_stream_status(Glib::unwrap(src),
     static_cast<GstStreamStatusType>(type), Glib::unwrap(owner));
-  return Gst::Message::wrap<MessageStreamStatus>(message, false);
+  return Glib::wrap(message, false);
 }
 
 void MessageStreamStatus::set_object(const Glib::RefPtr<Gst::Object>& object)
@@ -1015,195 +997,4 @@ Glib::RefPtr<Gst::Element> MessageStreamStatus::parse_owner() const
   return Glib::wrap(gst_element, true);
 }
 
-Glib::RefPtr<Gst::Message> Message::wrap(GstMessage* message, bool take_copy)
-{
-  Gst::Message* wrapper = 0;
-  Glib::RefPtr<Gst::Message> result;
-
-  if(!message)
-    return result;
-
-  GstMixerMessageType const mixer_message_type =
-    gst_mixer_message_get_type(message);
-
-  if(mixer_message_type == GST_MIXER_MESSAGE_INVALID)
-  {
-    switch(GST_MESSAGE_TYPE(message))
-    {
-      case GST_MESSAGE_EOS:
-        wrapper = new Gst::MessageEos(message);
-        break;
-      case GST_MESSAGE_ERROR:
-        wrapper = new Gst::MessageError(message);
-        break;
-      case GST_MESSAGE_WARNING:
-        wrapper = new Gst::MessageWarning(message);
-        break;
-      case GST_MESSAGE_INFO:
-        wrapper = new Gst::MessageInfo(message);
-        break;
-      case GST_MESSAGE_TAG:
-        wrapper = new Gst::MessageTag(message);
-        break;
-      case GST_MESSAGE_BUFFERING:
-        wrapper = new Gst::MessageBuffering(message);
-        break;
-      case GST_MESSAGE_STATE_CHANGED:
-        wrapper = new Gst::MessageStateChanged(message);
-        break;
-      case GST_MESSAGE_STATE_DIRTY:
-        wrapper = new Gst::MessageStateDirty(message);
-        break;
-      case GST_MESSAGE_STEP_DONE:
-        wrapper = new Gst::MessageStepDone(message);
-        break;
-      case GST_MESSAGE_CLOCK_PROVIDE:
-        wrapper = new Gst::MessageClockProvide(message);
-        break;
-      case GST_MESSAGE_CLOCK_LOST:
-        wrapper = new Gst::MessageClockLost(message);
-        break;
-      case GST_MESSAGE_NEW_CLOCK:
-        wrapper = new Gst::MessageNewClock(message);
-        break;
-      case GST_MESSAGE_APPLICATION:
-        wrapper = new Gst::MessageApplication(message);
-        break;
-      case GST_MESSAGE_ELEMENT:
-        wrapper = new Gst::MessageElement(message);
-        break;
-      case GST_MESSAGE_SEGMENT_START:
-        wrapper = new Gst::MessageSegmentStart(message);
-        break;
-      case GST_MESSAGE_SEGMENT_DONE:
-        wrapper = new Gst::MessageSegmentDone(message);
-        break;
-      case GST_MESSAGE_DURATION:
-        wrapper = new Gst::MessageDuration(message);
-        break;
-      case GST_MESSAGE_LATENCY:
-        wrapper = new Gst::MessageLatency(message);
-        break;
-      case GST_MESSAGE_ASYNC_START:
-        wrapper = new Gst::MessageAsyncStart(message);
-        break;
-      case GST_MESSAGE_ASYNC_DONE:
-        wrapper = new Gst::MessageAsyncDone(message);
-        break;
-      case GST_MESSAGE_STEP_START:
-        wrapper = new Gst::MessageStepStart(message);
-        break;
-      case GST_MESSAGE_STRUCTURE_CHANGE:
-        wrapper = new Gst::MessageStructureChange(message);
-        break;
-      case GST_MESSAGE_REQUEST_STATE:
-        wrapper = new Gst::MessageRequestState(message);
-        break;
-      case GST_MESSAGE_STREAM_STATUS:
-        wrapper = new Gst::MessageStreamStatus(message);
-        break;
-      case GST_MESSAGE_UNKNOWN:
-      case GST_MESSAGE_ANY:
-        wrapper = new Gst::Message(message);
-        break;
-        /* The rest of the message types are custom ones */
-      default:
-        wrapper = new Gst::MessageCustom(message);
-    }
-  }
-  else
-  {
-    switch(mixer_message_type)
-    {
-      case GST_MIXER_MESSAGE_MUTE_TOGGLED:
-        wrapper = new Gst::MessageMixerMuteToggled(message);
-        break;
-      case GST_MIXER_MESSAGE_RECORD_TOGGLED:
-        wrapper = new Gst::MessageMixerRecordToggled(message);
-        break;
-      case GST_MIXER_MESSAGE_VOLUME_CHANGED:
-        wrapper = new Gst::MessageMixerVolumeChanged(message);
-        break;
-      case GST_MIXER_MESSAGE_OPTION_CHANGED:
-        wrapper = new Gst::MessageMixerOptionChanged(message);
-        break;
-      case GST_MIXER_MESSAGE_OPTIONS_LIST_CHANGED:
-        wrapper = new Gst::MessageMixerOptionsListChanged(message);
-        break;
-      case GST_MIXER_MESSAGE_MIXER_CHANGED:
-        wrapper = new Gst::MessageMixerChanged(message);
-        break;
-      default:
-        wrapper = new Gst::MessageCustom(message);
-    }
-  }
-
-  result = Glib::RefPtr<Gst::Message>(wrapper);
-
-  // Ensure that the wrapper is freed when the message (mini object) is freed.
-  gst_mini_object_weak_ref(GST_MINI_OBJECT(message),
-    &Message_gstreamermm_callback_destroy, wrapper);
-
-  if(take_copy)
-    result->reference();
-
-  return result;
-}
-
-Gst::MiniObject* Message_Class::wrap_new(GstMiniObject* object)
-{
-  // Use the Gst::Message wrap() method to get the right type of Message class
-  // and return the underlying object in the refptr.  The extra reference is
-  // needed so that the object does not loose a reference when the local
-  // refptr is destroyed.
-  return Gst::Message::wrap((GstMessage*)object, true).operator->();
-}
-
-GstMiniObject* Message_Class::copy_vfunc_callback(const GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-    return (*GST_MINI_OBJECT_CLASS(base)->copy)(self);
-
-  return 0;
-}
-Glib::RefPtr<Gst::MiniObject> Message::copy_vfunc() const
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-  {
-    return Gst::Message::wrap(
-      GST_MESSAGE((*GST_MINI_OBJECT_CLASS(base)->copy)(
-        GST_MINI_OBJECT(gobj()))));
-  }
-
-  return Glib::RefPtr<Gst::MiniObject>(0);
-}
-void Message_Class::finalize_vfunc_callback(GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(self);
-}
-void Message::finalize_vfunc()
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(GST_MINI_OBJECT(gobj()));
-}
-
 } //namespace Gst
diff --git a/gstreamer/src/message.hg b/gstreamer/src/message.hg
index b4a1bac..a199051 100644
--- a/gstreamer/src/message.hg
+++ b/gstreamer/src/message.hg
@@ -19,7 +19,6 @@
 
 #include <gst/gstmessage.h>
 #include <gstreamermm/miniobject.h>
-#include <gstreamermm/wrap.h>
 #include <gstreamermm/format.h>
 #include <gstreamermm/clock.h>
 #include <gstreamermm/query.h>
@@ -73,18 +72,10 @@ class TagList;
  */
 class Message : public Gst::MiniObject
 {
-  _CLASS_GSTMINIOBJECT(Message, GstMessage, GST_MESSAGE, Gst::MiniObject, GstMiniObject)
+  _CLASS_OPAQUE_REFCOUNTED(Message, GstMessage, NONE, gst_message_ref, gst_message_unref)
   _IGNORE(gst_message_ref, gst_message_unref)
-  _CUSTOM_WRAP_NEW
 
 public:
-  /** Wrap a GstMessage in a C++ instance, creating an instance of a
-   *  derived Gst::Message.  Gst::wrap() would just create a Gst::Message
-   *  (rather than a derived one) because the derived Gst::Message classes
-   *  do not correspond to GType types in the GStreamer API.
-   */
-  static Glib::RefPtr<Gst::Message> wrap(GstMessage* message, bool take_copy = false);
-
 // A copy is taken so that the original is not freed by the wrapper.
 #m4 _CONVERSION(`const GstStructure*',`Gst::Structure',`Glib::wrap(const_cast<GstStructure*>($3), true)')
   _WRAP_METHOD(Gst::Structure get_structure() const, gst_message_get_structure)
@@ -111,25 +102,6 @@ public:
    */
   _MEMBER_GET_GOBJECT(source, src, Gst::Object, GstObject*)
 
-  /** Virtual function called when the Gst::Message needs to be copied.
-   */
-  virtual Glib::RefPtr<Gst::MiniObject> copy_vfunc() const;
-
-  /** Virtual function called when the Gst::Message is about to be finalized.
-   */
-  virtual void finalize_vfunc();
-
-protected:
-#m4begin
-  _PUSH(SECTION_PCC_CLASS_INIT_VFUNCS)
-  GST_MINI_OBJECT_CLASS(klass)->copy = &copy_vfunc_callback;
-  GST_MINI_OBJECT_CLASS(klass)->finalize = &finalize_vfunc_callback;
-  _SECTION(SECTION_PH_VFUNCS)
-  static GstMiniObject* copy_vfunc_callback(const GstMiniObject* self);
-  static void finalize_vfunc_callback(GstMiniObject* self);
-  _POP()
-#m4end
-
 protected:
   // This method is used in the create() methods to convert a wrapped
   // GstMessage to one of the more specific Gst::Message types.
@@ -1341,13 +1313,4 @@ public:
   Glib::RefPtr<Gst::Element> parse_owner() const;
 };
 
-/****************************** Gst::Message **************************/
-
-template <class MessageType>
-  Glib::RefPtr<MessageType> Message::wrap(GstMessage* message, bool take_copy)
-{
-  Glib::RefPtr<Gst::Message> result = wrap(message, take_copy);
-  return Glib::RefPtr<MessageType>::cast_dynamic(result);
-}
-
 } //namespace Gst
diff --git a/gstreamer/src/query.ccg b/gstreamer/src/query.ccg
index dcfcc66..bc9120e 100644
--- a/gstreamer/src/query.ccg
+++ b/gstreamer/src/query.ccg
@@ -23,24 +23,6 @@
 _PINCLUDE(gstreamermm/private/miniobject_p.h)
 #include <iostream>
 
-namespace
-{
-
-extern "C"
-{
-
-static void Query_gstreamermm_callback_destroy(void* data,
-  GstMiniObject* /* where_the_object_was */)
-{
-  // This works for any of the Gst::Query derived classes because none of
-  // them have member variables so in essence they are all the same size.
-  delete static_cast<Gst::Query*>(data);
-}
-
-}
-
-}
-
 namespace Gst
 {
 
@@ -61,7 +43,7 @@ Glib::QueryQuark get_quark(QueryType t)
 
 Glib::RefPtr<Gst::Query> Query::create_writable()
 {
-  return Gst::wrap(gst_query_make_writable(gobj()));
+  return Glib::wrap(gst_query_make_writable(gobj()));
 }
 
 QueryApplication::QueryApplication(GstQuery* castitem) :
@@ -75,7 +57,7 @@ Glib::RefPtr<Gst::QueryApplication>
   GstStructure* copy_struct = gst_structure_copy(structure.gobj());
   GstQuery* query = gst_query_new_application(GstQueryType(type),
     copy_struct); 
-  return Gst::Query::wrap<QueryApplication>(query);
+  return Glib::wrap(query);
 }
 
 QueryConvert::QueryConvert(GstQuery* castitem) :
@@ -87,7 +69,7 @@ Glib::RefPtr<Gst::QueryConvert>
 {
   GstQuery* query = gst_query_new_convert(GstFormat(src_format), value,
     GstFormat(dest_format));
-  return Gst::Query::wrap<QueryConvert>(query);
+  return Glib::wrap(query);
 }
 
 void QueryConvert::set(Format src_format, gint64 src_value, Format dest_format, gint64 dest_value)
@@ -147,7 +129,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QueryPosition> QueryPosition::create(Format format)
 {
   GstQuery* query = gst_query_new_position(GstFormat(format));
-  return Gst::Query::wrap<QueryPosition>(query);
+  return Glib::wrap(query);
 }
 
 void QueryPosition::set(Format format, gint64 position)
@@ -183,7 +165,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QueryDuration> QueryDuration::create(Format format)
 {
   GstQuery* query = gst_query_new_duration(GstFormat(format));
-  return Gst::Query::wrap<QueryDuration>(query);
+  return Glib::wrap(query);
 }
 
 void QueryDuration::set(Format format, gint64 duration)
@@ -219,7 +201,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QueryLatency> QueryLatency::create()
 {
   GstQuery* query = gst_query_new_latency();
-  return Gst::Query::wrap<QueryLatency>(query);
+  return Glib::wrap(query);
 }
 
 void QueryLatency::set(bool live, ClockTime min_latency, ClockTime max_latency)
@@ -266,7 +248,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QuerySeeking> QuerySeeking::create(Format format)
 {
   GstQuery* query = gst_query_new_seeking(GstFormat(format));
-  return Gst::Query::wrap<QuerySeeking>(query);
+  return Glib::wrap(query);
 }
 
 void QuerySeeking::set(Format format, bool seekable, gint64 segment_start, gint64 segment_end)
@@ -322,7 +304,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QueryFormats> QueryFormats::create()
 {
   GstQuery* query = gst_query_new_formats();
-  return Gst::Query::wrap<QueryFormats>(query);
+  return Glib::wrap(query);
 }
 
 void QueryFormats::set(const Glib::ArrayHandle<Format>& formats)
@@ -359,7 +341,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QuerySegment> QuerySegment::create(Format format)
 {
   GstQuery* query = gst_query_new_segment(GstFormat(format));
-  return Gst::Query::wrap<QuerySegment>(query);
+  return Glib::wrap(query);
 }
 
 void QuerySegment::set(double rate, Format format, gint64 start_value, gint64 stop_value)
@@ -413,7 +395,7 @@ Query(castitem)
 Glib::RefPtr<Gst::QueryBuffering> QueryBuffering::create(Format format)
 {
   GstQuery* query = gst_query_new_buffering(GstFormat(format));
-  return Gst::Query::wrap<QueryBuffering>(query);
+  return Glib::wrap(query);
 }
 
 void QueryBuffering::set(bool busy, int percent)
@@ -534,113 +516,4 @@ gint64 QueryBuffering::parse_total_time() const
   return estimated_total;
 }
 
-Glib::RefPtr<Gst::Query> Query::wrap(GstQuery* query, bool take_copy)
-{
-  Gst::Query* wrapper = 0;
-  Glib::RefPtr<Gst::Query> result;
-
-  if(!query)
-    return result;
-
-  switch(GST_QUERY_TYPE(query))
-  {
-    case GST_QUERY_POSITION:
-      wrapper = new Gst::QueryPosition(query);
-      break;
-    case GST_QUERY_DURATION:
-      wrapper = new Gst::QueryDuration(query);
-      break;
-    case GST_QUERY_LATENCY:
-      wrapper = new Gst::QueryLatency(query);
-      break;
-    case GST_QUERY_SEEKING:
-      wrapper = new Gst::QuerySeeking(query);
-      break;
-    case GST_QUERY_SEGMENT:
-      wrapper = new Gst::QuerySegment(query);
-      break;
-    case GST_QUERY_CONVERT:
-      wrapper = new Gst::QueryConvert(query);
-      break;
-    case GST_QUERY_FORMATS:
-      wrapper = new Gst::QueryFormats(query);
-      break;
-    case GST_QUERY_BUFFERING:
-      wrapper = new Gst::QueryBuffering(query);
-      break;
-    case GST_QUERY_NONE:
-    case GST_QUERY_JITTER:
-      wrapper = new Gst::Query(query);
-      break;
-        /* The rest of the query types are custom ones */
-    default:
-      wrapper = new Gst::QueryApplication(query);
-  }
-
-  result = Glib::RefPtr<Gst::Query>(wrapper);
-
-  // Ensure that the wrapper is freed when the query (mini object) is freed.
-  gst_mini_object_weak_ref(GST_MINI_OBJECT(query), &Query_gstreamermm_callback_destroy, wrapper);
-
-  if(take_copy)
-    result->reference();
-
-  return result;
-}
-
-Gst::MiniObject* Query_Class::wrap_new(GstMiniObject* object)
-{
-  // Use the Gst::Query wrap() method to get the right type of Query class
-  // and return the underlying object in the refptr.  The extra reference is
-  // needed so that the object does not loose a reference when the local refptr
-  // is destroyed.
-  return Gst::Query::wrap((GstQuery*)object, true).operator->();
-}
-
-GstMiniObject* Query_Class::copy_vfunc_callback(const GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-    return (*GST_MINI_OBJECT_CLASS(base)->copy)(self);
-
-  return 0;
-}
-Glib::RefPtr<Gst::MiniObject> Query::copy_vfunc() const
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->copy)
-  {
-    return Gst::Query::wrap(GST_QUERY((*GST_MINI_OBJECT_CLASS(base)->copy)(
-        GST_MINI_OBJECT(gobj()))));
-  }
-
-  return Glib::RefPtr<Gst::MiniObject>(0);
-}
-void Query_Class::finalize_vfunc_callback(GstMiniObject* self)
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(GST_MINI_OBJECT_GET_CLASS(self)) // Get the parent class of the object class 
(The original underlying C class).
-  );
-
-  // Call the original underlying C function:
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(self);
-}
-void Query::finalize_vfunc()
-{
-  BaseClassType *const base = static_cast<BaseClassType*>(
-      g_type_class_peek_parent(G_OBJECT_GET_CLASS(gobj())) // Get the parent class of the object class (The 
original underlying C class).
-  );
-
-  if(base && GST_MINI_OBJECT_CLASS(base)->finalize)
-    (*GST_MINI_OBJECT_CLASS(base)->finalize)(GST_MINI_OBJECT(gobj()));
-}
-
 } //namesapce Gst
diff --git a/gstreamer/src/query.hg b/gstreamer/src/query.hg
index ecb66cb..7b49a86 100644
--- a/gstreamer/src/query.hg
+++ b/gstreamer/src/query.hg
@@ -20,7 +20,6 @@
 #include <gst/gstquery.h>
 #include <gstreamermm/miniobject.h>
 #include <gstreamermm/structure.h>
-#include <gstreamermm/wrap.h>
 #include <gstreamermm/format.h>
 #include <glibmm/arrayhandle.h>
 
@@ -99,18 +98,10 @@ _IGNORE(gst_query_type_to_quark)
  */
 class Query : public MiniObject
 {
-  _CLASS_GSTMINIOBJECT(Query, GstQuery, GST_QUERY, Gst::MiniObject, GstMiniObject)
-  _IGNORE(gst_query_ref, qgst_query_unref)
-  _CUSTOM_WRAP_NEW
+  _CLASS_OPAQUE_REFCOUNTED(Query, GstQuery, NONE, gst_query_ref, gst_query_unref)
+  _IGNORE(gst_query_ref, gst_query_unref)
 
 public:
-  /** Wrap a GstQuery in a C++ instance, creating an instance of a derived
-   * Gst::Query. Gst::wrap() would just create a Gst::Query (rather than a
-   * derived one) because the derived Gst::Query classes do not correspond
-   * to GType types in the GStreamer API.
-   */
-  static Glib::RefPtr<Gst::Query> wrap(GstQuery* query, bool take_copy = false);
-
    /** Makes a writable query from the given query.  Does exactly what
     * Gst::MiniObject::create_writable() does for the Gst::Query.
     * @return A Gst::Query (possibly the same pointer) that is writable.
@@ -131,25 +122,6 @@ public:
 #m4 _CONVERSION(`const Glib::ArrayHandle<const QueryType>&',`GstQueryType*',`(GstQueryType*)(($3).data())')
   _WRAP_METHOD(static bool query_types_contain(const Glib::ArrayHandle<const QueryType>& types, QueryType 
type), gst_query_types_contains)
 
-  /** Virtual function called when the Gst::Query needs to be copied.
-   */
-  virtual Glib::RefPtr<Gst::MiniObject> copy_vfunc() const;
-
-  /** Virtual function called when the Gst::Query is about to be finalized.
-   */
-  virtual void finalize_vfunc();
-
-protected:
-#m4begin
-  _PUSH(SECTION_PCC_CLASS_INIT_VFUNCS)
-  GST_MINI_OBJECT_CLASS(klass)->copy = &copy_vfunc_callback;
-  GST_MINI_OBJECT_CLASS(klass)->finalize = &finalize_vfunc_callback;
-  _SECTION(SECTION_PH_VFUNCS)
-  static GstMiniObject* copy_vfunc_callback(const GstMiniObject* self);
-  static void finalize_vfunc_callback(GstMiniObject* self);
-  _POP()
-#m4end
-
 protected:
   // This method is used in the create() methods to convert a wrapped GstQuery
   // to one of the more specific Gst::Query types.
@@ -659,13 +631,4 @@ public:
   gint64 parse_total_time() const;
 };
 
-/****************************** Gst::Query **************************/
-
-template <class QueryType>
-  Glib::RefPtr<QueryType> Query::wrap(GstQuery* query, bool take_copy)
-{
-  Glib::RefPtr<Gst::Query> result = wrap(query, take_copy);
-  return Glib::RefPtr<QueryType>::cast_dynamic(result);
-}
-
 } //namespace Gst
diff --git a/tools/extra_defs_gen/generate_plugin_gmmproc_file.cc 
b/tools/extra_defs_gen/generate_plugin_gmmproc_file.cc
index 7eb06ca..ad9068e 100644
--- a/tools/extra_defs_gen/generate_plugin_gmmproc_file.cc
+++ b/tools/extra_defs_gen/generate_plugin_gmmproc_file.cc
@@ -254,36 +254,6 @@ static std::string get_c_enum_definition_macro(GType enumGType,
   return result;
 }
 
-static bool is_a_mini_object(const std::string& cType)
-{
-  // Add the mini object types to this array.  Keep a final null member so the
-  // loop that tests for the types knows when to stop iterating through the
-  // types.
-  static const char *const mini_object_types[] =
-  {
-    "GstBuffer",
-    "GstBufferList",
-    "GstEvent",
-    "GstMessage",
-    "GstMiniObject",
-    "GstQuery",
-    0
-  };
-
-  // Note that if the C type is a mini object, it would be a pointer so remove
-  // the last character (the '*') so the comparison with the above types works.
-  const std::string cTypeName = cType.substr(0, cType.size() - 1);
-
-  for(const char* const* type = mini_object_types; *type != 0; type++)
-  {
-    if(cTypeName == *type)
-    {
-      return true;
-    }
-  }
-  return false;
-}
-
 static std::string get_signal_wrap_statements(std::string& includeMacroCalls,
                                               std::string& cEnumDefinitions,
                                               std::string& enumWrapStatements,
@@ -424,13 +394,6 @@ static std::string get_signal_wrap_statements(std::string& includeMacroCalls,
             convertMacros += "#m4 _CONVERSION(``" + returnCType + "'', _LQ()" +
               returnCTypeTranslation + "_RQ(), ``Glib::wrap_taglist($3)'')\n";
           }
-          else if(is_a_mini_object(returnCType))
-          {
-            // Dealing with a mini object (which are boxed types).
-            convertMacros += "#m4 _CONVERSION(``" + returnCType +
-              "'', _LQ()" + returnCTypeTranslation + "_RQ(), " +
-              "``Gst::wrap($3)'')\n";
-          }
           else
           {
             // Dealing with a regular boxed type return.
@@ -543,13 +506,6 @@ static std::string get_signal_wrap_statements(std::string& includeMacroCalls,
                 "_LQ()" + paramCTypeTranslation + "_RQ(), "
                 "``Glib::wrap_taglist($3, true)'')\n";
             }
-            else if(is_a_mini_object(paramCType))
-            {
-              // Dealing with a mini object (which are boxed types).
-              convertMacros += "#m4 _CONVERSION(``" + paramCType +
-                "'', _LQ()" + paramCTypeTranslation + "_RQ(), " +
-                "``Gst::wrap($3, true)'')\n";
-            }
             else
             {
               // Dealing with reference counted parameter or a boxed type.
diff --git a/tools/m4/convert.m4 b/tools/m4/convert.m4
index 2345c07..103f28f 100644
--- a/tools/m4/convert.m4
+++ b/tools/m4/convert.m4
@@ -3,6 +3,5 @@ dnl Copyright 2008 The gstreamermm Development Team
 include(convert_base.m4)
 include(convert_glib.m4)
 include(convert_gst.m4)
-include(class_gstminiobject.m4)
 include(class_boxedtype_extra.m4)
 include(shared.m4)
diff --git a/tools/m4/filelist.am b/tools/m4/filelist.am
index 5c26d14..7defa9b 100644
--- a/tools/m4/filelist.am
+++ b/tools/m4/filelist.am
@@ -1,6 +1,5 @@
 ## Copyright 2009 The gstreamermm Development Team.
 
-files_codegen_m4 = convert.m4 convert_gst.m4 class_gstminiobject.m4 \
-                   class_boxedtype_extra.m4 shared.m4
+files_codegen_m4 = convert.m4 convert_gst.m4 class_boxedtype_extra.m4 shared.m4
 
 files_plugin_m4 = plugingen_base.m4 plugingen.m4 plugingen_gstreamermm.m4
[Date Prev][Date Next] [Thread Prev][Thread Next] [Thread Index] [Date Index] [Author Index]