[gstreamermm] C++11: use nullptr

[Marcin Kolny <mkolny src gnome org>]

commit b47e0dd9373d6afdb168016e227604fa30136f2a
Author: Marcin Kolny <marcin kolny gmail com>
Date:   Fri Aug 7 20:54:48 2015 +0000

    C++11: use nullptr
    
        * gstreamer/gstreamermm/atomicqueue.h:
        * gstreamer/gstreamermm/init.cc:
        * gstreamer/gstreamermm/register.h:
        * gstreamer/src/allocator.ccg:
        * gstreamer/src/audioringbuffer.ccg:
        * gstreamer/src/basesink.ccg:
        * gstreamer/src/buffer.ccg:
        * gstreamer/src/bufferlist.ccg:
        * gstreamer/src/caps.ccg:
        * gstreamer/src/capsfeatures.ccg:
        * gstreamer/src/childproxy.ccg:
        * gstreamer/src/clock.ccg:
        * gstreamer/src/discovererinfo.ccg:
        * gstreamer/src/element.ccg:
        * gstreamer/src/event.ccg:
        * gstreamer/src/iterator.hg:
        * gstreamer/src/message.ccg:
        * gstreamer/src/miniobject.ccg:
        * gstreamer/src/mixer.ccg:
        * gstreamer/src/pad.ccg:
        * gstreamer/src/parse.ccg:
        * gstreamer/src/preset.ccg:
        * gstreamer/src/query.ccg:
        * gstreamer/src/structure.ccg:
        * gstreamer/src/taglist.ccg:
        * gstreamer/src/typefind.ccg:
        * gstreamer/src/urihandler.ccg: replace 'NULL' and '0' with nullptr
          where possible.

 gstreamer/gstreamermm/atomicqueue.h |    4 +-
 gstreamer/gstreamermm/init.cc       |    8 +-
 gstreamer/gstreamermm/register.h    |   10 +-
 gstreamer/src/allocator.ccg         |    2 +-
 gstreamer/src/audioringbuffer.ccg   |    2 +-
 gstreamer/src/basesink.ccg          |    2 +-
 gstreamer/src/buffer.ccg            |    2 +-
 gstreamer/src/bufferlist.ccg        |    2 +-
 gstreamer/src/caps.ccg              |    2 +-
 gstreamer/src/capsfeatures.ccg      |    2 +-
 gstreamer/src/childproxy.ccg        |    2 +-
 gstreamer/src/clock.ccg             |    4 +-
 gstreamer/src/discovererinfo.ccg    |    2 +-
 gstreamer/src/element.ccg           |    4 +-
 gstreamer/src/event.ccg             |    8 +-
 gstreamer/src/iterator.hg           |    2 +-
 gstreamer/src/message.ccg           |  154 +++++++++++++++++-----------------
 gstreamer/src/miniobject.ccg        |    4 +-
 gstreamer/src/mixer.ccg             |   42 +++++-----
 gstreamer/src/pad.ccg               |   14 ++--
 gstreamer/src/parse.ccg             |    6 +-
 gstreamer/src/preset.ccg            |    6 +-
 gstreamer/src/query.ccg             |   90 ++++++++++----------
 gstreamer/src/structure.ccg         |   38 +++++-----
 gstreamer/src/taglist.ccg           |    4 +-
 gstreamer/src/typefind.ccg          |   20 +++---
 gstreamer/src/urihandler.ccg        |    8 +-
 27 files changed, 222 insertions(+), 222 deletions(-)
---
diff --git a/gstreamer/gstreamermm/atomicqueue.h b/gstreamer/gstreamermm/atomicqueue.h
index e9b168b..066a05e 100644
--- a/gstreamer/gstreamermm/atomicqueue.h
+++ b/gstreamer/gstreamermm/atomicqueue.h
@@ -134,7 +134,7 @@ public:
   T peek()
   {
     gpointer val = gst_atomic_queue_peek(gobj());
-    if (val == 0)
+    if (val == nullptr)
       gstreamermm_handle_error("Queue is empty");
     T v = *(T*)val;
     return v;
@@ -148,7 +148,7 @@ public:
   T pop()
   {
     gpointer val = gst_atomic_queue_pop(gobj());
-    if (val == 0)
+    if (val == nullptr)
       gstreamermm_handle_error("Queue is empty");
     T v = *(T*)val;
     delete (T*)val;
diff --git a/gstreamer/gstreamermm/init.cc b/gstreamer/gstreamermm/init.cc
index 37608d8..427abd1 100644
--- a/gstreamer/gstreamermm/init.cc
+++ b/gstreamer/gstreamermm/init.cc
@@ -54,7 +54,7 @@ void init()
   if(!s_init)
   {
     Glib::init();
-    gst_init(0, 0);
+    gst_init(nullptr, nullptr);
     initialize_wrap_system();
     s_init = true;
   }
@@ -69,7 +69,7 @@ bool init_check(int& argc, char**& argv)
   {
     Glib::init();
 
-    GError* gerror = 0;
+    GError* gerror = nullptr;
     result = gst_init_check(&argc, &argv, &gerror);
 
     if(gerror)
@@ -91,8 +91,8 @@ bool init_check()
   {
     Glib::init();
 
-    GError* gerror = 0;
-    result = gst_init_check(0, 0, &gerror);
+    GError* gerror = nullptr;
+    result = gst_init_check(nullptr, nullptr, &gerror);
 
     if(gerror)
       ::Glib::Error::throw_exception(gerror);
diff --git a/gstreamer/gstreamermm/register.h b/gstreamer/gstreamermm/register.h
index c89fe59..33ee09b 100644
--- a/gstreamer/gstreamermm/register.h
+++ b/gstreamer/gstreamermm/register.h
@@ -120,14 +120,14 @@ register_mm_type(const gchar * type_name)
 
         info.class_size = sizeof(GlibCppTypeClass);
         info.base_init = (GBaseInitFunc)&GlibCppType::base_init;
-        info.base_finalize = 0;
+        info.base_finalize = nullptr;
         info.class_init = (GClassInitFunc) &GlibCppTypeClass::init;
-        info.class_finalize = 0;
-        info.class_data = 0;
+        info.class_finalize = nullptr;
+        info.class_data = nullptr;
         info.instance_size = sizeof(GlibCppType);
-        info.n_preallocs = 0;
+        info.n_preallocs = nullptr;
         info.instance_init = (GInstanceInitFunc) &GlibCppType::init;
-        info.value_table = 0;
+        info.value_table = nullptr;
 
         GType _type = g_type_register_static(parent_type, type_name, &info, (GTypeFlags)0);
         g_once_init_leave(&gonce_data, (gsize) _type);
diff --git a/gstreamer/src/allocator.ccg b/gstreamer/src/allocator.ccg
index 37aa11d..8dee06c 100644
--- a/gstreamer/src/allocator.ccg
+++ b/gstreamer/src/allocator.ccg
@@ -43,7 +43,7 @@ void Allocator::register_allocator(const Glib::ustring& name)
 
 Glib::RefPtr<Gst::Allocator> Allocator::get_default_allocator()
 {
-  return Glib::wrap(gst_allocator_find(NULL), false);
+  return Glib::wrap(gst_allocator_find(nullptr), false);
 }
 
 void Allocator::set_default()
diff --git a/gstreamer/src/audioringbuffer.ccg b/gstreamer/src/audioringbuffer.ccg
index b052884..3af78ed 100644
--- a/gstreamer/src/audioringbuffer.ccg
+++ b/gstreamer/src/audioringbuffer.ccg
@@ -133,7 +133,7 @@ void AudioRingBufferSpec::swap(AudioRingBufferSpec& other)
 bool AudioRingBuffer::prepare_read(int& segment, std::vector<guint8>& readptr,
   int& len)
 {
-  guint8* c_readptr = 0;
+  guint8* c_readptr = nullptr;
 
   const bool result = static_cast<bool>(gst_audio_ring_buffer_prepare_read(gobj(), &segment, &c_readptr, 
&len));
   readptr.assign(c_readptr, c_readptr + len);
diff --git a/gstreamer/src/basesink.ccg b/gstreamer/src/basesink.ccg
index 65875ac..9bbffa2 100644
--- a/gstreamer/src/basesink.ccg
+++ b/gstreamer/src/basesink.ccg
@@ -43,7 +43,7 @@ bool BaseSink::query_latency(bool& live, bool& upstream_live, ClockTime& min_lat
 
 ClockReturn BaseSink::wait_clock(ClockTime time)
 {
-  return static_cast<ClockReturn>(gst_base_sink_wait_clock(const_cast<GstBaseSink*>(gobj()), 
static_cast<GstClockTime>(time), 0));
+  return static_cast<ClockReturn>(gst_base_sink_wait_clock(const_cast<GstBaseSink*>(gobj()), 
static_cast<GstClockTime>(time), nullptr));
 }
 
 FlowReturn BaseSink::wait(ClockTime time)
diff --git a/gstreamer/src/buffer.ccg b/gstreamer/src/buffer.ccg
index dec627c..8a9a27c 100644
--- a/gstreamer/src/buffer.ccg
+++ b/gstreamer/src/buffer.ccg
@@ -32,7 +32,7 @@ Glib::RefPtr<Gst::Buffer> Buffer::copy() const
 
 Glib::RefPtr<Gst::Buffer> Buffer::create(guint size)
 {
-  return Glib::wrap(gst_buffer_new_allocate(NULL, size, NULL));
+  return Glib::wrap(gst_buffer_new_allocate(nullptr, size, nullptr));
 }
 
 Glib::RefPtr<Buffer> Buffer::create_writable()
diff --git a/gstreamer/src/bufferlist.ccg b/gstreamer/src/bufferlist.ccg
index 63aada9..d27be53 100644
--- a/gstreamer/src/bufferlist.ccg
+++ b/gstreamer/src/bufferlist.ccg
@@ -43,7 +43,7 @@ static gboolean BufferList_Foreach_gstreamermm_callback(GstBuffer** buffer, guin
     if(!temp)
     {
       // Clear the reference to the original buffer also.
-      *buffer = 0;
+      *buffer = nullptr;
     }
     else if(*buffer != temp->gobj())
     {
diff --git a/gstreamer/src/caps.ccg b/gstreamer/src/caps.ccg
index d50cb5f..eab7b07 100644
--- a/gstreamer/src/caps.ccg
+++ b/gstreamer/src/caps.ccg
@@ -51,7 +51,7 @@ Glib::RefPtr<Gst::Caps> Caps::create(const Structure& structure)
 {
   //We take a copy because gst_caps_append_structure() wants to take ownership:
   GstStructure* copy = gst_structure_copy(structure.gobj());
-  return Glib::wrap(gst_caps_new_full(copy, NULL));
+  return Glib::wrap(gst_caps_new_full(copy, nullptr));
 }
 
 void Caps::append_structure(const Structure& structure)
diff --git a/gstreamer/src/capsfeatures.ccg b/gstreamer/src/capsfeatures.ccg
index 0a2fccc..b79193f 100644
--- a/gstreamer/src/capsfeatures.ccg
+++ b/gstreamer/src/capsfeatures.ccg
@@ -29,7 +29,7 @@ CapsFeatures::CapsFeatures()
 
 CapsFeatures::CapsFeatures(const Glib::ustring& feature1)
 {
-  gobject_ =  gst_caps_features_new(feature1.c_str(), NULL);
+  gobject_ =  gst_caps_features_new(feature1.c_str(), nullptr);
 }
 
 CapsFeatures CapsFeatures::create_any()
diff --git a/gstreamer/src/childproxy.ccg b/gstreamer/src/childproxy.ccg
index 7aec3de..3d1ae2b 100644
--- a/gstreamer/src/childproxy.ccg
+++ b/gstreamer/src/childproxy.ccg
@@ -24,7 +24,7 @@ bool ChildProxy::lookup(const Glib::RefPtr<Gst::ChildProxy>& object,
   const Glib::ustring& name, Glib::RefPtr<Glib::Object>& target,
   GParamSpec*& pspec)
 {
-  GObject* g_object = 0;
+  GObject* g_object = nullptr;
   bool const result = gst_child_proxy_lookup(Glib::unwrap(object),
     name.c_str(), &g_object, &pspec);
   target = Glib::wrap(g_object);
diff --git a/gstreamer/src/clock.ccg b/gstreamer/src/clock.ccg
index 6e7c793..60b5072 100644
--- a/gstreamer/src/clock.ccg
+++ b/gstreamer/src/clock.ccg
@@ -101,12 +101,12 @@ guint get_fractional_seconds(ClockTime time)
 ClockReturn ClockID::wait_async(const SlotClock& slot)
 {
   SlotClock* slot_copy = new SlotClock(slot);
-  return static_cast<ClockReturn>(gst_clock_id_wait_async(gobj(), &ClockID_Clock_gstreamermm_callback, 
slot_copy, NULL)); // TODO temporary NULL value
+  return static_cast<ClockReturn>(gst_clock_id_wait_async(gobj(), &ClockID_Clock_gstreamermm_callback, 
slot_copy, nullptr)); // TODO temporary NULL value
 }
 
 ClockReturn ClockID::wait()
 {
-  return static_cast<ClockReturn>(gst_clock_id_wait(gobj(), 0));
+  return static_cast<ClockReturn>(gst_clock_id_wait(gobj(), nullptr));
 }
 
 } //namespace Gst
diff --git a/gstreamer/src/discovererinfo.ccg b/gstreamer/src/discovererinfo.ccg
index f833368..6e8caef 100644
--- a/gstreamer/src/discovererinfo.ccg
+++ b/gstreamer/src/discovererinfo.ccg
@@ -30,6 +30,6 @@ namespace Gst
 static GstDiscovererInfo *
 gst_discoverer_info_new (void)
 {
-  return (GstDiscovererInfo *) g_object_new (GST_TYPE_DISCOVERER_INFO, NULL);
+  return (GstDiscovererInfo *) g_object_new (GST_TYPE_DISCOVERER_INFO, nullptr);
 }
 }
diff --git a/gstreamer/src/element.ccg b/gstreamer/src/element.ccg
index dc25aa2..3889e8a 100644
--- a/gstreamer/src/element.ccg
+++ b/gstreamer/src/element.ccg
@@ -98,12 +98,12 @@ void Element::post_message(int code, int line, MessageType type,
 
 bool Element::query_position(Gst::Format format) const
 {
-  return gst_element_query_position(const_cast<GstElement*>(gobj()), (GstFormat)format, 0);
+  return gst_element_query_position(const_cast<GstElement*>(gobj()), (GstFormat)format, nullptr);
 }
 
 bool Element::query_duration(Format format) const
 {
-  return gst_element_query_duration(const_cast<GstElement*>(gobj()), (GstFormat)format, 0);
+  return gst_element_query_duration(const_cast<GstElement*>(gobj()), (GstFormat)format, nullptr);
 }
 
 // This method is written manually because an extra ref is necessary. See
diff --git a/gstreamer/src/event.ccg b/gstreamer/src/event.ccg
index 6087209..27eee2f 100644
--- a/gstreamer/src/event.ccg
+++ b/gstreamer/src/event.ccg
@@ -134,7 +134,7 @@ gint64 EventBufferSize::parse() const
 {
   gint64 gst_minsize = 0;
   gst_event_parse_buffer_size(const_cast<GstEvent*>(gobj()), 0, &gst_minsize,
-    0, 0);
+    nullptr, nullptr);
   return gst_minsize;
 }
 
@@ -362,14 +362,14 @@ Glib::RefPtr<Gst::EventSinkMessage>
 
 Glib::RefPtr<Gst::Message> EventSinkMessage::parse()
 {
-  GstMessage* gst_msg = 0;
+  GstMessage* gst_msg = nullptr;
   gst_event_parse_sink_message(gobj(), &gst_msg);
   return Glib::wrap(gst_msg);
 }
 
 Glib::RefPtr<const Gst::Message> EventSinkMessage::parse() const
 {
-  GstMessage* gst_msg = 0;
+  GstMessage* gst_msg = nullptr;
   gst_event_parse_sink_message(const_cast<GstEvent*>(gobj()), &gst_msg);
   return Glib::wrap(gst_msg);
 }
@@ -390,7 +390,7 @@ EventCaps::create(const Glib::RefPtr<Gst::Caps>& caps)
 
 Glib::RefPtr<Gst::Caps> EventCaps::parse()
 {
-  GstCaps* gst_caps = 0;
+  GstCaps* gst_caps = nullptr;
   gst_event_parse_caps(gobj(), &gst_caps);
   return Glib::wrap(gst_caps, true);
 }
diff --git a/gstreamer/src/iterator.hg b/gstreamer/src/iterator.hg
index 620a2a6..d0a27f9 100644
--- a/gstreamer/src/iterator.hg
+++ b/gstreamer/src/iterator.hg
@@ -344,7 +344,7 @@ IteratorBase<CppType>::~IteratorBase()
   if(take_ownership && cobject_)
   {
     gst_iterator_free(cobject_);
-    cobject_ = 0;
+    cobject_ = nullptr;
   }
   if(G_IS_VALUE(this->current))
     g_value_unset(this->current);
diff --git a/gstreamer/src/message.ccg b/gstreamer/src/message.ccg
index ab616fc..aebf596 100644
--- a/gstreamer/src/message.ccg
+++ b/gstreamer/src/message.ccg
@@ -66,8 +66,8 @@ Glib::RefPtr<Gst::MessageError>
 
 void MessageError::parse(Glib::Error& error, std::string& debug) const
 {
-  GError* c_error = 0;
-  gchar* c_debug = 0;
+  GError* c_error = nullptr;
+  gchar* c_debug = nullptr;
   gst_message_parse_error(const_cast<GstMessage*>(gobj()), &c_error, &c_debug);
 
   debug = c_debug;
@@ -79,16 +79,16 @@ void MessageError::parse(Glib::Error& error, std::string& debug) const
 
 Glib::Error MessageError::parse() const
 {
-  GError* c_error = 0;
-  gst_message_parse_error(const_cast<GstMessage*>(gobj()), &c_error, 0);
+  GError* c_error = nullptr;
+  gst_message_parse_error(const_cast<GstMessage*>(gobj()), &c_error, nullptr);
 
   return Glib::Error(c_error);
 }
 
 std::string MessageError::parse_debug() const
 {
-  gchar* c_debug = 0;
-  GError* c_error = 0;
+  gchar* c_debug = nullptr;
+  GError* c_error = nullptr;
 
   gst_message_parse_error(const_cast<GstMessage*>(gobj()), &c_error, &c_debug);
 
@@ -114,8 +114,8 @@ Glib::RefPtr<Gst::MessageWarning>
 
 void MessageWarning::parse(Glib::Error& error, std::string& debug) const
 {
-  GError* c_error = 0;
-  gchar* c_debug = 0;
+  GError* c_error = nullptr;
+  gchar* c_debug = nullptr;
   gst_message_parse_warning(const_cast<GstMessage*>(gobj()), &c_error, &c_debug);
 
   debug = c_debug;
@@ -127,16 +127,16 @@ void MessageWarning::parse(Glib::Error& error, std::string& debug) const
 
 Glib::Error MessageWarning::parse() const
 {
-  GError* c_error = 0;
-  gst_message_parse_warning(const_cast<GstMessage*>(gobj()), &c_error, 0);
+  GError* c_error = nullptr;
+  gst_message_parse_warning(const_cast<GstMessage*>(gobj()), &c_error, nullptr);
 
   return Glib::Error(c_error);
 }
 
 std::string MessageWarning::parse_debug() const
 {
-  gchar* c_debug = 0;
-  GError* c_error = 0;
+  gchar* c_debug = nullptr;
+  GError* c_error = nullptr;
 
   gst_message_parse_warning(const_cast<GstMessage*>(gobj()), &c_error,
     &c_debug);
@@ -164,8 +164,8 @@ Glib::RefPtr<Gst::MessageInfo>
 
 void MessageInfo::parse(Glib::Error& error, std::string& debug) const
 {
-  GError* c_error = 0;
-  gchar* c_debug = 0;
+  GError* c_error = nullptr;
+  gchar* c_debug = nullptr;
   gst_message_parse_info(const_cast<GstMessage*>(gobj()), &c_error, &c_debug);
 
   debug = c_debug;
@@ -177,16 +177,16 @@ void MessageInfo::parse(Glib::Error& error, std::string& debug) const
 
 Glib::Error MessageInfo::parse() const
 {
-  GError* c_error = 0;
-  gst_message_parse_info(const_cast<GstMessage*>(gobj()), &c_error, 0);
+  GError* c_error = nullptr;
+  gst_message_parse_info(const_cast<GstMessage*>(gobj()), &c_error, nullptr);
 
   return Glib::Error(c_error);
 }
 
 std::string MessageInfo::parse_debug() const
 {
-  gchar* c_debug = 0;
-  GError* c_error = 0;
+  gchar* c_debug = nullptr;
+  GError* c_error = nullptr;
 
   gst_message_parse_info(const_cast<GstMessage*>(gobj()), &c_error, &c_debug);
 
@@ -212,7 +212,7 @@ Glib::RefPtr<Gst::MessageTag>
 void MessageTag::parse(Gst::TagList& tag_list)
   const
 {
-  GstTagList* gst_tag_list = 0;
+  GstTagList* gst_tag_list = nullptr;
 
   gst_message_parse_tag(const_cast<GstMessage*>(gobj()), &gst_tag_list);
 
@@ -222,7 +222,7 @@ void MessageTag::parse(Gst::TagList& tag_list)
 
 Gst::TagList MessageTag::parse() const
 {
-  GstTagList* gst_tag_list = 0;
+  GstTagList* gst_tag_list = nullptr;
   gst_message_parse_tag(const_cast<GstMessage*>(gobj()), &gst_tag_list);
   return Gst::TagList(gst_tag_list);
 }
@@ -261,7 +261,7 @@ BufferingMode MessageBuffering::parse_stats_buffering_mode() const
   GstBufferingMode mode = GST_BUFFERING_STREAM;
 
   gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), &mode,
-    0, 0, 0);
+    nullptr, nullptr, nullptr);
   return static_cast<BufferingMode>(mode);
 }
 
@@ -269,8 +269,8 @@ int MessageBuffering::parse_stats_avg_in() const
 {
   int avg_in = 0;
 
-  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), 0,
-    &avg_in, 0, 0);
+  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), nullptr,
+    &avg_in, nullptr, nullptr);
   return avg_in;
 }
 
@@ -278,8 +278,8 @@ int MessageBuffering::parse_stats_avg_out() const
 {
   int avg_out = 0;
 
-  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), 0,
-    0, &avg_out, 0);
+  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), nullptr,
+    nullptr, &avg_out, nullptr);
   return avg_out;
 }
 
@@ -287,8 +287,8 @@ gint64 MessageBuffering::parse_stats_buffering_left() const
 {
   gint64 buffering_left = 0;
 
-  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), 0,
-    0, 0, &buffering_left);
+  gst_message_parse_buffering_stats(const_cast<GstMessage*>(gobj()), nullptr,
+    nullptr, nullptr, &buffering_left);
   return buffering_left;
 }
 
@@ -315,8 +315,8 @@ State MessageStateChanged::parse() const
 {
   GstState new_state = GST_STATE_NULL;
 
-  gst_message_parse_state_changed(const_cast<GstMessage*>(gobj()), 0,
-    &new_state, 0);
+  gst_message_parse_state_changed(const_cast<GstMessage*>(gobj()), nullptr,
+    &new_state, nullptr);
   return State(new_state);
 }
 
@@ -325,15 +325,15 @@ State MessageStateChanged::parse_old() const
   GstState old_state = GST_STATE_NULL;
 
   gst_message_parse_state_changed(const_cast<GstMessage*>(gobj()), &old_state,
-    0, 0);
+    nullptr, nullptr);
   return State(old_state);
 }
 
 State MessageStateChanged::parse_pending() const
 {
   GstState pending_state = GST_STATE_NULL;
-  gst_message_parse_state_changed(const_cast<GstMessage*>(gobj()), 0,
-    0, &pending_state);
+  gst_message_parse_state_changed(const_cast<GstMessage*>(gobj()), nullptr,
+    nullptr, &pending_state);
   return State(pending_state);
 }
 
@@ -374,8 +374,8 @@ void MessageStepDone::parse(Gst::Format& format, guint64& amount, double& rate,
 guint64 MessageStepDone::parse() const
 {
   guint64 duration = 0;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, 0, 0, 0, 0,
-    &duration, 0);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, nullptr, nullptr,
+    &duration, nullptr);
   return duration;
 }
 
@@ -383,47 +383,47 @@ Gst::Format MessageStepDone::parse_format() const
 {
   GstFormat format = GST_FORMAT_UNDEFINED;
   gst_message_parse_step_done(const_cast<GstMessage*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0, 0, 0, 0, 0, 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr, nullptr, nullptr, nullptr);
   return static_cast<Gst::Format>(format);
 }
 
 guint64 MessageStepDone::parse_amount() const
 {
   guint64 amount = 0;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, &amount, 0,
-    0, 0, 0, 0);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, &amount, nullptr,
+    nullptr, nullptr, nullptr, nullptr);
   return amount;
 }
 
 double MessageStepDone::parse_rate() const
 {
   double rate = 0;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, 0, &rate, 0,
-    0, 0, 0);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, nullptr, &rate, nullptr,
+    nullptr, nullptr, nullptr);
   return rate;
 }
 
 bool MessageStepDone::parse_flush() const
 {
   gboolean gst_flush = FALSE;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, 0, 0,
-    &gst_flush, 0, 0, 0);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr,
+    &gst_flush, nullptr, nullptr, nullptr);
   return gst_flush;
 }
 
 bool MessageStepDone::parse_intermediate() const
 {
   gboolean gst_intermediate = FALSE;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, 0, 0, 0,
-    &gst_intermediate, 0, 0);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, nullptr,
+    &gst_intermediate, nullptr, nullptr);
   return gst_intermediate;
 }
 
 bool MessageStepDone::parse_eos() const
 {
   gboolean gst_eos = FALSE;
-  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), 0, 0, 0, 0, 0,
-    0, &gst_eos);
+  gst_message_parse_step_done(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, nullptr, nullptr,
+    nullptr, &gst_eos);
   return gst_eos;
 }
 
@@ -438,7 +438,7 @@ Glib::RefPtr<Gst::MessageClockProvide>
 
 void MessageClockProvide::parse(Glib::RefPtr<Gst::Clock>& clock, bool& ready) const
 {
-  GstClock* cclock = 0;
+  GstClock* cclock = nullptr;
   gboolean ready_ = false;
   gst_message_parse_clock_provide(const_cast<GstMessage*>(gobj()), &cclock,
     &ready_);
@@ -448,8 +448,8 @@ void MessageClockProvide::parse(Glib::RefPtr<Gst::Clock>& clock, bool& ready) co
 
 Glib::RefPtr<Gst::Clock> MessageClockProvide::parse()
 {
-  GstClock* cclock = 0;
-  gst_message_parse_clock_provide(gobj(), &cclock, 0);
+  GstClock* cclock = nullptr;
+  gst_message_parse_clock_provide(gobj(), &cclock, nullptr);
   return Glib::wrap(cclock);
 }
 
@@ -461,7 +461,7 @@ Glib::RefPtr<const Gst::Clock> MessageClockProvide::parse() const
 bool MessageClockProvide::parse_ready() const
 {
   gboolean ready = FALSE;
-  gst_message_parse_clock_provide(const_cast<GstMessage*>(gobj()), 0,
+  gst_message_parse_clock_provide(const_cast<GstMessage*>(gobj()), nullptr,
     &ready);
   return ready;
 }
@@ -477,7 +477,7 @@ Glib::RefPtr<Gst::MessageClockLost>
 
 Glib::RefPtr<Gst::Clock> MessageClockLost::parse()
 {
-  GstClock* cclock = 0;
+  GstClock* cclock = nullptr;
   gst_message_parse_clock_lost(gobj(), &cclock);
   return Glib::wrap(cclock, false);
 }
@@ -498,7 +498,7 @@ Glib::RefPtr<Gst::MessageNewClock>
 
 Glib::RefPtr<Gst::Clock> MessageNewClock::parse()
 {
-  GstClock* cclock = 0;
+  GstClock* cclock = nullptr;
   gst_message_parse_new_clock(gobj(), &cclock);
   return Glib::wrap(cclock, false);
 }
@@ -531,7 +531,7 @@ Glib::RefPtr<Gst::MessageElement>
 Glib::RefPtr<Gst::MessageElement>
   MessageElement::create(const Glib::RefPtr<Gst::Object>& src)
 {
-  GstMessage* message = gst_message_new_element(Glib::unwrap(src), 0);
+  GstMessage* message = gst_message_new_element(Glib::unwrap(src), nullptr);
   return Gst::wrap_msg_derived<Gst::MessageElement>(message, false);
 }
 
@@ -549,7 +549,7 @@ Glib::RefPtr<Gst::MessageCustom>
   MessageCustom::create(MessageType type, const Glib::RefPtr<Gst::Object>& src)
 {
   GstMessage* message = gst_message_new_custom(GstMessageType(type),
-    Glib::unwrap(src), 0);
+    Glib::unwrap(src), nullptr);
   return Gst::wrap_msg_derived<Gst::MessageCustom>(message, false);
 }
 
@@ -571,7 +571,7 @@ void MessageSegmentStart::parse(Format& format, gint64& position) const
 gint64 MessageSegmentStart::parse() const
 {
   gint64 position = 0;
-  gst_message_parse_segment_start(const_cast<GstMessage*>(gobj()), 0,
+  gst_message_parse_segment_start(const_cast<GstMessage*>(gobj()), nullptr,
     &position);
   return position;
 }
@@ -580,7 +580,7 @@ Format MessageSegmentStart::parse_format() const
 {
   Format format = Gst::FORMAT_DEFAULT;
   gst_message_parse_segment_start(const_cast<GstMessage*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr);
   return format;
 }
 
@@ -602,7 +602,7 @@ void MessageSegmentDone::parse(Format& format, gint64& position) const
 gint64 MessageSegmentDone::parse() const
 {
   gint64 position = 0;
-  gst_message_parse_segment_done(const_cast<GstMessage*>(gobj()), 0,
+  gst_message_parse_segment_done(const_cast<GstMessage*>(gobj()), nullptr,
     &position);
   return position;
 }
@@ -611,7 +611,7 @@ Format MessageSegmentDone::parse_format() const
 {
   Format format = Gst::FORMAT_UNDEFINED;
   gst_message_parse_segment_done(const_cast<GstMessage*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr);
   return format;
 }
 
@@ -679,47 +679,47 @@ void MessageStepStart::parse(bool& active, Gst::Format& format,
 guint64 MessageStepStart::parse() const
 {
   guint64 amount = 0;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), 0, 0, &amount,
-    0, 0, 0);
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), nullptr, nullptr, &amount,
+    nullptr, nullptr, nullptr);
   return amount;
 }
 
 bool MessageStepStart::parse_active() const
 {
   gboolean gst_active = FALSE;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), &gst_active, 0,
-    0, 0, 0, 0);
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), &gst_active, nullptr,
+    nullptr, nullptr, nullptr, nullptr);
   return gst_active;
 }
 
 Gst::Format MessageStepStart::parse_format() const
 {
   GstFormat format = GST_FORMAT_UNDEFINED;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), 0,
-    reinterpret_cast<GstFormat*>(&format), 0, 0, 0, 0);
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), nullptr,
+    reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr, nullptr);
   return static_cast<Gst::Format>(format);
 }
 
 double MessageStepStart::parse_rate() const
 {
   double rate = 0;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), 0, 0, 0, &rate,
-    0, 0);
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, &rate,
+    nullptr, nullptr);
   return rate;
 }
 
 bool MessageStepStart::parse_flush() const
 {
   gboolean gst_flush = FALSE;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), 0, 0, 0, 0,
-    &gst_flush, 0);
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, nullptr,
+    &gst_flush, nullptr);
   return gst_flush;
 }
 
 bool MessageStepStart::parse_intermediate() const
 {
   gboolean gst_intermediate = FALSE;
-  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), 0, 0, 0, 0, 0,
+  gst_message_parse_step_start(const_cast<GstMessage*>(gobj()), nullptr, nullptr, nullptr, nullptr, nullptr,
     &gst_intermediate);
   return gst_intermediate;
 }
@@ -737,7 +737,7 @@ Glib::RefPtr<Gst::MessageStructureChange>
 void MessageStructureChange::parse(Gst::StructureChangeType& type,
   Glib::RefPtr<Gst::Element>& owner, bool& busy) const
 {
-  GstElement* gst_element = 0;
+  GstElement* gst_element = nullptr;
   gboolean gst_busy = false;
   gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()),
     reinterpret_cast<GstStructureChangeType*>(&type), &gst_element, &gst_busy);
@@ -749,22 +749,22 @@ Gst::StructureChangeType MessageStructureChange::parse() const
 {
   GstStructureChangeType gst_type = GST_STRUCTURE_CHANGE_TYPE_PAD_LINK;
   gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()),
-    &gst_type, 0, 0);
+    &gst_type, nullptr, nullptr);
   return static_cast<Gst::StructureChangeType>(gst_type);
 }
 
 Glib::RefPtr<Gst::Element> MessageStructureChange::parse_owner() const
 {
-  GstElement* gst_element = 0;
-  gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()), 0,
-    &gst_element, 0);
+  GstElement* gst_element = nullptr;
+  gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()), nullptr,
+    &gst_element, nullptr);
   return Glib::wrap(gst_element, true);
 }
 
 bool MessageStructureChange::parse_busy() const
 {
   gboolean gst_busy = false;
-  gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()), 0, 0,
+  gst_message_parse_structure_change(const_cast<GstMessage*>(gobj()), nullptr, nullptr,
     &gst_busy);
   return gst_busy;
 }
@@ -825,14 +825,14 @@ Gst::StreamStatusType MessageStreamStatus::parse() const
 {
   GstStreamStatusType type;
   gst_message_parse_stream_status(const_cast<GstMessage*>(gobj()),
-    &type, 0);
+    &type, nullptr);
   return static_cast<Gst::StreamStatusType>(type);
 }
 
 Glib::RefPtr<Gst::Element> MessageStreamStatus::parse_owner() const
 {
   GstElement* gst_element;
-  gst_message_parse_stream_status(const_cast<GstMessage*>(gobj()), 0,
+  gst_message_parse_stream_status(const_cast<GstMessage*>(gobj()), nullptr,
     &gst_element);
   return Glib::wrap(gst_element, true);
 }
@@ -918,7 +918,7 @@ Glib::RefPtr<Gst::MessageNeedContext> MessageNeedContext::create(
 
 bool MessageNeedContext::parse(Glib::ustring& context_type) const
 {
-  gchar* c_context_type = 0;
+  gchar* c_context_type = nullptr;
   bool ret = gst_message_parse_context_type(const_cast<GstMessage*>(gobj()),
     const_cast<const gchar**>(&c_context_type));
   context_type = c_context_type;
diff --git a/gstreamer/src/miniobject.ccg b/gstreamer/src/miniobject.ccg
index 2f7d7ea..c605497 100644
--- a/gstreamer/src/miniobject.ccg
+++ b/gstreamer/src/miniobject.ccg
@@ -40,7 +40,7 @@ MiniObject::~MiniObject()
   if (finalizers.find(gobject_) != finalizers.end())
   {
     delete finalizers[gobject_];
-    finalizers[gobject_] = NULL;
+    finalizers[gobject_] = nullptr;
   }
 }
 
@@ -118,7 +118,7 @@ void MiniObject::remove_finalize_notifier()
   {
     gst_mini_object_weak_unref(gobj(), &MiniObject::MiniObject_Finalizer_gstreamermm_callback, 
finalizers[gobj()]);
     delete finalizers[gobj()];
-    finalizers[gobj()] = NULL;
+    finalizers[gobj()] = nullptr;
   }
 }
 
diff --git a/gstreamer/src/mixer.ccg b/gstreamer/src/mixer.ccg
index 821673c..7c03349 100644
--- a/gstreamer/src/mixer.ccg
+++ b/gstreamer/src/mixer.ccg
@@ -30,7 +30,7 @@ MessageMixerMuteToggled::MessageMixerMuteToggled(GstMessage* castitem)
 void MessageMixerMuteToggled::parse(Glib::RefPtr<Gst::MixerTrack>& track,
   bool& mute) const
 {
-  GstMixerTrack* gst_track = 0;
+  GstMixerTrack* gst_track = nullptr;
   gboolean gst_mute = 0;
 
   gst_mixer_message_parse_mute_toggled(const_cast<GstMessage*>(gobj()),
@@ -41,8 +41,8 @@ void MessageMixerMuteToggled::parse(Glib::RefPtr<Gst::MixerTrack>& track,
 
 Glib::RefPtr<Gst::MixerTrack> MessageMixerMuteToggled::parse()
 {
-  GstMixerTrack* gst_track = 0;
-  gst_mixer_message_parse_mute_toggled(gobj(), &gst_track, 0);
+  GstMixerTrack* gst_track = nullptr;
+  gst_mixer_message_parse_mute_toggled(gobj(), &gst_track, nullptr);
   return Glib::wrap(gst_track);
 }
 
@@ -55,7 +55,7 @@ bool MessageMixerMuteToggled::parse_mute() const
 {
   gboolean gst_mute = 0;
   gst_mixer_message_parse_mute_toggled(const_cast<GstMessage*>(gobj()),
-    0, &gst_mute);
+    nullptr, &gst_mute);
   return gst_mute;
 }
 
@@ -66,7 +66,7 @@ MessageMixerRecordToggled::MessageMixerRecordToggled(GstMessage* castitem)
 void MessageMixerRecordToggled::parse(Glib::RefPtr<Gst::MixerTrack>& track,
   bool& record) const
 {
-  GstMixerTrack* gst_track = 0;
+  GstMixerTrack* gst_track = nullptr;
   gboolean gst_record = 0;
 
   gst_mixer_message_parse_record_toggled(const_cast<GstMessage*>(gobj()),
@@ -77,8 +77,8 @@ void MessageMixerRecordToggled::parse(Glib::RefPtr<Gst::MixerTrack>& track,
 
 Glib::RefPtr<Gst::MixerTrack> MessageMixerRecordToggled::parse()
 {
-  GstMixerTrack* gst_track = 0;
-  gst_mixer_message_parse_record_toggled(gobj(), &gst_track, 0);
+  GstMixerTrack* gst_track = nullptr;
+  gst_mixer_message_parse_record_toggled(gobj(), &gst_track, nullptr);
   return Glib::wrap(gst_track);
 }
 
@@ -91,7 +91,7 @@ bool MessageMixerRecordToggled::parse_record() const
 {
   gboolean gst_record = 0;
   gst_mixer_message_parse_record_toggled(const_cast<GstMessage*>(gobj()),
-    0, &gst_record);
+    nullptr, &gst_record);
   return gst_record;
 }
 
@@ -102,8 +102,8 @@ MessageMixerVolumeChanged::MessageMixerVolumeChanged(GstMessage* castitem)
 void MessageMixerVolumeChanged::parse(Glib::RefPtr<Gst::MixerTrack>& track,
   std::vector<int>& volumes) const
 {
-  GstMixerTrack* gst_track = 0;
-  gint* gst_volumes = 0;
+  GstMixerTrack* gst_track = nullptr;
+  gint* gst_volumes = nullptr;
   gint gst_num_channels = 0;
 
   gst_mixer_message_parse_volume_changed(const_cast<GstMessage*>(gobj()),
@@ -117,8 +117,8 @@ void MessageMixerVolumeChanged::parse(Glib::RefPtr<Gst::MixerTrack>& track,
 
 Glib::RefPtr<Gst::MixerTrack> MessageMixerVolumeChanged::parse()
 {
-  GstMixerTrack* gst_track = 0;
-  gst_mixer_message_parse_volume_changed(gobj(), &gst_track, 0, 0);
+  GstMixerTrack* gst_track = nullptr;
+  gst_mixer_message_parse_volume_changed(gobj(), &gst_track, nullptr, nullptr);
   return Glib::wrap(gst_track);
 }
 
@@ -129,11 +129,11 @@ Glib::RefPtr<const Gst::MixerTrack> MessageMixerVolumeChanged::parse() const
 
 std::vector<int> MessageMixerVolumeChanged::parse_volumes() const
 {
-  gint* gst_volumes = 0;
+  gint* gst_volumes = nullptr;
   gint gst_num_channels = 0;
 
   gst_mixer_message_parse_volume_changed(const_cast<GstMessage*>(gobj()),
-    0, &gst_volumes, &gst_num_channels);
+    nullptr, &gst_volumes, &gst_num_channels);
 
   return Glib::ArrayHandle<int>(gst_volumes, gst_num_channels,
     Glib::OWNERSHIP_DEEP);
@@ -146,8 +146,8 @@ MessageMixerOptionChanged::MessageMixerOptionChanged(GstMessage* castitem)
 void MessageMixerOptionChanged::parse(Glib::RefPtr<Gst::MixerOptions>& options,
   Glib::ustring& value) const
 {
-  GstMixerOptions* gst_options = 0;
-  const gchar* gst_value = 0;
+  GstMixerOptions* gst_options = nullptr;
+  const gchar* gst_value = nullptr;
 
   gst_mixer_message_parse_option_changed(const_cast<GstMessage*>(gobj()),
     &gst_options, &gst_value);
@@ -157,8 +157,8 @@ void MessageMixerOptionChanged::parse(Glib::RefPtr<Gst::MixerOptions>& options,
 
 Glib::RefPtr<Gst::MixerOptions> MessageMixerOptionChanged::parse()
 {
-  GstMixerOptions* gst_options = 0;
-  gst_mixer_message_parse_option_changed(gobj(), &gst_options, 0);
+  GstMixerOptions* gst_options = nullptr;
+  gst_mixer_message_parse_option_changed(gobj(), &gst_options, nullptr);
   return Glib::wrap(gst_options);
 }
 
@@ -169,9 +169,9 @@ Glib::RefPtr<const Gst::MixerOptions> MessageMixerOptionChanged::parse() const
 
 Glib::ustring MessageMixerOptionChanged::parse_value() const
 {
-  const gchar* gst_value = 0;
+  const gchar* gst_value = nullptr;
   gst_mixer_message_parse_option_changed(const_cast<GstMessage*>(gobj()),
-    0, &gst_value);
+    nullptr, &gst_value);
   return gst_value;
 }
 
@@ -181,7 +181,7 @@ MessageMixerOptionsListChanged::MessageMixerOptionsListChanged(GstMessage* casti
 
 Glib::RefPtr<Gst::MixerOptions> MessageMixerOptionsListChanged::parse()
 {
-  GstMixerOptions* gst_options = 0;
+  GstMixerOptions* gst_options = nullptr;
   gst_mixer_message_parse_options_list_changed(gobj(), &gst_options);
   return Glib::wrap(gst_options);
 }
diff --git a/gstreamer/src/pad.ccg b/gstreamer/src/pad.ccg
index 1f4b458..ef66692 100644
--- a/gstreamer/src/pad.ccg
+++ b/gstreamer/src/pad.ccg
@@ -67,12 +67,12 @@ namespace Gst
 {
 
 Pad::Pad(PadDirection dir)
-  : _CONSTRUCT("name", static_cast<char*>(0), "direction", dir)
+  : _CONSTRUCT("name", nullptr, "direction", dir)
 {}
 
 Pad::Pad(const Glib::RefPtr<const Gst::PadTemplate>& templ,
   const Glib::ustring& name)
-  : _CONSTRUCT("name", (name.empty() ? static_cast<char*>(0) : name.c_str()),
+  : _CONSTRUCT("name", (name.empty() ? nullptr : name.c_str()),
     "direction", (templ ? static_cast<GstPadDirection>(templ->get_direction())
       : GST_PAD_UNKNOWN),
     "template", Glib::unwrap(templ))
@@ -85,7 +85,7 @@ Pad::Pad(const Glib::RefPtr<const Gst::PadTemplate>& templ,
 }
 
 Pad::Pad(const Glib::RefPtr<const Gst::PadTemplate>& templ)
-  : _CONSTRUCT("name", static_cast<char*>(0),
+  : _CONSTRUCT("name", nullptr,
     "direction", (templ ? static_cast<GstPadDirection>(templ->get_direction())
       : GST_PAD_UNKNOWN),
     "template", Glib::unwrap(templ))
@@ -139,7 +139,7 @@ gulong Pad::add_probe(PadProbeType mask, const SlotProbe& slot)
 
 FlowReturn Pad::get_range(guint64 offset, guint size, Glib::RefPtr<Gst::Buffer>& buffer)
 {
-  GstBuffer* c_buffer = 0;
+  GstBuffer* c_buffer = nullptr;
   GstFlowReturn result = gst_pad_get_range(gobj(), offset, size, &c_buffer);
   buffer = Glib::wrap(c_buffer, false);
   return FlowReturn(result);
@@ -164,7 +164,7 @@ bool Pad::push_event(const Glib::RefPtr<Gst::Event>& event)
 
 FlowReturn Pad::pull_range(guint64 offset, guint size, Glib::RefPtr<Gst::Buffer>& buffer)
 {
-  GstBuffer* c_buffer = 0;
+  GstBuffer* c_buffer = nullptr;
   GstFlowReturn result = gst_pad_pull_range(gobj(), offset, size, &c_buffer);
   buffer = Glib::wrap(c_buffer, false);
   return FlowReturn(result);
@@ -178,12 +178,12 @@ bool Pad::send_event(const Glib::RefPtr<Gst::Event>& event)
 
 bool Pad::query_position(Format& format) const
 {
-  return gst_pad_query_position(const_cast<GstPad*>(gobj()), (GstFormat)format, 0);
+  return gst_pad_query_position(const_cast<GstPad*>(gobj()), (GstFormat)format, nullptr);
 }
 
 bool Pad::query_duration(Format& format) const
 {
-  return gst_pad_query_duration(const_cast<GstPad*>(gobj()), (GstFormat)format, 0);
+  return gst_pad_query_duration(const_cast<GstPad*>(gobj()), (GstFormat)format, nullptr);
 }
 
 FlowReturn Pad::chain(Glib::RefPtr<Gst::Buffer>& buffer)
diff --git a/gstreamer/src/parse.ccg b/gstreamer/src/parse.ccg
index 7cb4432..ef0387a 100644
--- a/gstreamer/src/parse.ccg
+++ b/gstreamer/src/parse.ccg
@@ -25,7 +25,7 @@ namespace Gst
 
 Glib::RefPtr<Gst::Element> Parse::launch(const Glib::ustring& pipeline_description)
 {
-  GError* gerror = 0;
+  GError* gerror = nullptr;
   Glib::RefPtr<Gst::Element> retvalue = Glib::wrap(gst_parse_launch(pipeline_description.c_str(), &gerror));
 
   if(gerror)
@@ -36,7 +36,7 @@ Glib::RefPtr<Gst::Element> Parse::launch(const Glib::ustring& pipeline_descripti
 
 Glib::RefPtr<Gst::Element> Parse::launchv(const gchar *argv[])
 {
-  GError* gerror = 0;
+  GError* gerror = nullptr;
   Glib::RefPtr<Gst::Element> retvalue = Glib::wrap(gst_parse_launchv(argv, &gerror));
 
   if(gerror)
@@ -47,7 +47,7 @@ Glib::RefPtr<Gst::Element> Parse::launchv(const gchar *argv[])
 
 Glib::RefPtr<Gst::Element> Parse::create_bin(const Glib::ustring& bin_description, bool 
ghost_unconnected_pads)
 {
-  GError* gerror = 0;
+  GError* gerror = nullptr;
   Glib::RefPtr<Gst::Element> retvalue = Glib::wrap(gst_parse_bin_from_description(bin_description.c_str(), 
ghost_unconnected_pads, &gerror));
 
   if(gerror)
diff --git a/gstreamer/src/preset.ccg b/gstreamer/src/preset.ccg
index c9e9710..d12839c 100644
--- a/gstreamer/src/preset.ccg
+++ b/gstreamer/src/preset.ccg
@@ -23,7 +23,7 @@ namespace Gst
 bool Preset::get_meta(const Glib::ustring& name, const Glib::ustring& tag,
   Glib::ustring& value) const
 {
-  gchar* meta = 0;
+  gchar* meta = nullptr;
 
   gboolean result = gst_preset_get_meta(const_cast<GstPreset*>(gobj()),
     name.c_str(), tag.c_str(), &meta);
@@ -166,7 +166,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_preset_names)
     return Glib::StringArrayHandle((*base->get_preset_names)(const_cast<GstPreset*>(gobj())), 
Glib::OWNERSHIP_DEEP);
 
-  return Glib::StringArrayHandle(0, Glib::OWNERSHIP_NONE);
+  return Glib::StringArrayHandle(nullptr, Glib::OWNERSHIP_NONE);
 }
 Glib::StringArrayHandle Gst::Preset::get_property_names_vfunc() const
 {
@@ -178,7 +178,7 @@ g_type_interface_peek(G_OBJECT_GET_CLASS(gobject_), CppObjectType::get_type()) /
   if(base && base->get_property_names)
     return Glib::StringArrayHandle((*base->get_property_names)(const_cast<GstPreset*>(gobj())), 
Glib::OWNERSHIP_DEEP);
 
-  return Glib::StringArrayHandle(0, Glib::OWNERSHIP_NONE);
+  return Glib::StringArrayHandle(nullptr, Glib::OWNERSHIP_NONE);
 }
 bool Gst::Preset::get_meta_vfunc(const Glib::ustring& name,
   const Glib::ustring& tag, Glib::ustring& value) const
diff --git a/gstreamer/src/query.ccg b/gstreamer/src/query.ccg
index 23c23d0..e52aa8d 100644
--- a/gstreamer/src/query.ccg
+++ b/gstreamer/src/query.ccg
@@ -84,7 +84,7 @@ void QueryConvert::parse(Format& src_format, gint64& src_value, Format& dest_for
 
 void QueryConvert::parse(Format& dest_format, gint64& dest_value) const
 {
-  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 0, 0,
+  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
     reinterpret_cast<GstFormat*>(&dest_format), &dest_value);
 }
 
@@ -92,30 +92,30 @@ Format QueryConvert::parse_src_format() const
 {
   Format src_format = Gst::FORMAT_UNDEFINED;
   gst_query_parse_convert(const_cast<GstQuery*>(gobj()),
-    reinterpret_cast<GstFormat*>(&src_format), 0, 0, 0);
+    reinterpret_cast<GstFormat*>(&src_format), nullptr, nullptr, nullptr);
   return src_format;
 }
 
 gint64 QueryConvert::parse_src_value() const
 {
   gint64 src_value = 0;
-  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 0, &src_value,
-    0, 0);
+  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, &src_value,
+    nullptr, nullptr);
   return src_value;
 }
 
 Format QueryConvert::parse_dest_format() const
 {
   Format dest_format = Gst::FORMAT_UNDEFINED;
-  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 0, 0,
-    reinterpret_cast<GstFormat*>(&dest_format), 0);
+  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
+    reinterpret_cast<GstFormat*>(&dest_format), nullptr);
   return dest_format;
 }
 
 gint64 QueryConvert::parse_dest_value() const
 {
   gint64 dest_value = 0;
-  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), 0, 0, 0,
+  gst_query_parse_convert(const_cast<GstQuery*>(gobj()), nullptr, nullptr, nullptr,
     &dest_value);
   return dest_value;
 }
@@ -140,7 +140,7 @@ void QueryPosition::parse(Format& format, gint64& position) const
 gint64 QueryPosition::parse() const
 {
   gint64 position = 0;
-  gst_query_parse_position(const_cast<GstQuery*>(gobj()), 0, &position);
+  gst_query_parse_position(const_cast<GstQuery*>(gobj()), nullptr, &position);
   return position;
 }
 
@@ -148,7 +148,7 @@ Format QueryPosition::parse_format() const
 {
   Format format = Gst::FORMAT_UNDEFINED;
   gst_query_parse_position(const_cast<GstQuery*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr);
   return format;
 }
 
@@ -172,7 +172,7 @@ void QueryDuration::parse(Format& format, gint64& duration) const
 gint64 QueryDuration::parse() const
 {
   gint64 duration = 0;
-  gst_query_parse_duration(const_cast<GstQuery*>(gobj()), 0, &duration);
+  gst_query_parse_duration(const_cast<GstQuery*>(gobj()), nullptr, &duration);
   return duration;
 }
 
@@ -207,22 +207,22 @@ void QueryLatency::parse(bool& live, ClockTime& min_latency, ClockTime& max_late
 bool QueryLatency::parse_live() const
 {
   gboolean glive = FALSE;
-  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), &glive, 0, 0);
+  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), &glive, nullptr, nullptr);
   return glive;
 }
 
 ClockTime QueryLatency::parse_min() const
 {
   ClockTime min = 0;
-  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), 0,
-    reinterpret_cast<ClockTime*>(&min), 0);
+  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), nullptr,
+    reinterpret_cast<ClockTime*>(&min), nullptr);
   return min;
 }
 
 ClockTime QueryLatency::parse_max() const
 {
   ClockTime max = 0;
-  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), 0, 0,
+  gst_query_parse_latency(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
     reinterpret_cast<ClockTime*>(&max));
   return max;
 }
@@ -251,30 +251,30 @@ Format QuerySeeking::parse_format() const
 {
   Format format = Gst::FORMAT_UNDEFINED;
   gst_query_parse_seeking(const_cast<GstQuery*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0, 0, 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr);
   return format;
 }
 
 bool QuerySeeking::parse_seekable() const
 {
   gboolean gseekable = FALSE;
-  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), 0,
-    &gseekable, 0, 0);
+  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr,
+    &gseekable, nullptr, nullptr);
   return gseekable;
 }
 
 gint64 QuerySeeking::parse_start() const
 {
   gint64 start = 0;
-  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), 0, 0,
-    &start, 0);
+  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
+    &start, nullptr);
   return start;
 }
 
 gint64 QuerySeeking::parse_end() const
 {
   gint64 end = 0;
-  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), 0, 0, 0,
+  gst_query_parse_seeking(const_cast<GstQuery*>(gobj()), nullptr, nullptr, nullptr,
     &end);
   return end;
 }
@@ -333,32 +333,32 @@ void QuerySegment::parse(double& rate, Format& format, gint64& start_value, gint
 double QuerySegment::parse_rate() const
 {
   double rate = 0;
-  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), &rate, 0,
-    0, 0);
+  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), &rate, nullptr,
+    nullptr, nullptr);
   return rate;
 }
 
 Format QuerySegment::parse_format() const
 {
   Format format = Gst::FORMAT_UNDEFINED;
-  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), 0,
-    reinterpret_cast<GstFormat*>(&format), 0, 0);
+  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr,
+    reinterpret_cast<GstFormat*>(&format), nullptr, nullptr);
   return format;
 }
 
 gint64 QuerySegment::parse_start() const
 {
   gint64 start = 0;
-  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), 0, 0,
-    &start, 0);
+  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
+    &start, nullptr);
   return start;
 }
 
 gint64 QuerySegment::parse_stop() const
 {
   gint64 stop = 0;
-  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), 0, 0,
-    0, &stop);
+  gst_query_parse_segment(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
+    nullptr, &stop);
   return stop;
 }
 
@@ -392,7 +392,7 @@ bool QueryBuffering::parse_busy() const
 int QueryBuffering::parse_percent() const
 {
   int percent = 0;
-  gst_query_parse_buffering_percent(const_cast<GstQuery*>(gobj()), 0,
+  gst_query_parse_buffering_percent(const_cast<GstQuery*>(gobj()), nullptr,
     &percent);
   return percent;
 }
@@ -414,31 +414,31 @@ BufferingMode QueryBuffering::parse_mode() const
 {
   BufferingMode mode = Gst::BUFFERING_STREAM;
   gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()),
-    reinterpret_cast<GstBufferingMode*>(&mode), 0, 0, 0);
+    reinterpret_cast<GstBufferingMode*>(&mode), nullptr, nullptr, nullptr);
   return mode;
 }
 
 int QueryBuffering::parse_input_rate() const
 {
   int avg_in = 0;
-  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), 0,
-    &avg_in, 0, 0);
+  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr,
+    &avg_in, nullptr, nullptr);
   return avg_in;
 }
 
 int QueryBuffering::parse_output_rate() const
 {
   int avg_out = 0;
-  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), 0, 0,
-    &avg_out, 0);
+  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr, nullptr,
+    &avg_out, nullptr);
   return avg_out;
 }
 
 gint64 QueryBuffering::parse_time_left() const
 {
   gint64 buffering_left = Gst::BUFFERING_STREAM;
-  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), 0,
-    0, 0, &buffering_left);
+  gst_query_parse_buffering_stats(const_cast<GstQuery*>(gobj()), nullptr,
+    nullptr, nullptr, &buffering_left);
   return buffering_left;
 }
 
@@ -458,31 +458,31 @@ Format QueryBuffering::parse_format() const
 {
   Format format = Gst::FORMAT_UNDEFINED;
   gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()),
-    reinterpret_cast<GstFormat*>(&format), 0, 0, 0);
+    reinterpret_cast<GstFormat*>(&format), nullptr, nullptr, nullptr);
   return format;
 }
 
 gint64 QueryBuffering::parse_start() const
 {
   gint64 start = 0;
-  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), 0,
-    &start, 0, 0);
+  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr,
+    &start, nullptr, nullptr);
   return start;
 }
 
 gint64 QueryBuffering::parse_stop() const
 {
   gint64 stop = 0;
-  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), 0,
-    0, &stop, 0);
+  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr,
+    nullptr, &stop, nullptr);
   return stop;
 }
 
 gint64 QueryBuffering::parse_total_time() const
 {
   gint64 estimated_total = 0;
-  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), 0,
-    0, 0, &estimated_total);
+  gst_query_parse_buffering_range(const_cast<GstQuery*>(gobj()), nullptr,
+    nullptr, nullptr, &estimated_total);
   return estimated_total;
 }
 
@@ -645,7 +645,7 @@ Glib::ustring QueryUri::parse() const
   gchar* gst_uri;
   Glib::ustring uri;
   gst_query_parse_uri(const_cast<GstQuery*>(gobj()), &gst_uri);
-  if (gst_uri != NULL)
+  if (gst_uri != nullptr)
   {
     uri = gst_uri;
     g_free(gst_uri);
@@ -670,7 +670,7 @@ Glib::ustring QueryUri::parse_uri_redirection() const
   Glib::ustring uri;
   gst_query_parse_uri_redirection(const_cast<GstQuery*>(gobj()), &c_uri);
 
-  if (c_uri != NULL)
+  if (c_uri != nullptr)
   {
     uri = c_uri;
     g_free(c_uri);
diff --git a/gstreamer/src/structure.ccg b/gstreamer/src/structure.ccg
index afdbec3..4912e87 100644
--- a/gstreamer/src/structure.ccg
+++ b/gstreamer/src/structure.ccg
@@ -86,7 +86,7 @@ Structure::Structure(const Glib::ustring& name)
 
 Structure::operator const void*() const
 {
-  return gobject_ ? GINT_TO_POINTER(1) : 0;
+  return gobject_ ? GINT_TO_POINTER(1) : nullptr;
 }
 
 void Structure::get_field(const Glib::ustring& name, Glib::ValueBase& value) const
@@ -102,85 +102,85 @@ void Structure::set_field(const Glib::ustring& fieldname,
 
 void Structure::set_field(const Glib::ustring& fieldname, bool value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_BOOLEAN, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_BOOLEAN, value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, int value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_INT, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_INT, value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, guint value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_UINT, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_UINT, value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, double value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DOUBLE, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DOUBLE, value, nullptr);
 };
 
 //We use std::string, because the encoding is unknown. murrayc
 void Structure::set_field(const Glib::ustring& fieldname, const std::string& value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_STRING, value.c_str(), (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_STRING, value.c_str(), nullptr);
 }
 
 //We use std::string, because the encoding is unknown. murrayc
 void Structure::set_field(const Glib::ustring& fieldname, const char* value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_STRING, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_STRING, value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Glib::Date& value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DATE, value.gobj(), (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DATE, value.gobj(), nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Glib::DateTime& value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DATE_TIME, value.gobj(), (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_DATE_TIME, value.gobj(), nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, gint64 value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_INT64,
-    (gint64) value, (void*)0);
+    (gint64) value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, guint64 value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), G_TYPE_INT64,
-    (guint64) value, (void*)0);
+    (guint64) value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, GType enumtype, int value)
 {
-  gst_structure_set(gobj(), fieldname.c_str(), enumtype, value, (void*)0);
+  gst_structure_set(gobj(), fieldname.c_str(), enumtype, value, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Gst::Fraction& value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_FRACTION, value.num,
-    value.denom, (void*)0);
+    value.denom, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Gst::IntRange& value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_INT_RANGE, value.min,
-    value.max, (void*)0);
+    value.max, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Gst::DoubleRange& value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_DOUBLE_RANGE,
-    value.min, value.max, (void*)0);
+    value.min, value.max, nullptr);
 }
 
 void Structure::set_field(const Glib::ustring& fieldname, const Gst::FractionRange& value)
 {
   gst_structure_set(gobj(), fieldname.c_str(), GST_TYPE_FRACTION_RANGE,
-    value.min.num, value.min.denom, value.max.num, value.max.denom, (void*)0);
+    value.min.num, value.min.denom, value.max.num, value.max.denom, nullptr);
 }
 
 void Structure::remove_field(const Glib::ustring& fieldname)
@@ -247,7 +247,7 @@ bool Structure::get_field(const Glib::ustring& name, std::string& value) const
 
 bool Structure::get_field(const Glib::ustring& name, Glib::Date& date) const
 {
-  GDate* gdate = 0;
+  GDate* gdate = nullptr;
   const bool has = gst_structure_get_date(gobj(), name.c_str(), &gdate);
   if(has)
     date.set_julian(Glib::Date(*gdate).get_julian());
@@ -257,7 +257,7 @@ bool Structure::get_field(const Glib::ustring& name, Glib::Date& date) const
 
 bool Structure::get_field(const Glib::ustring& name, Glib::DateTime& datetime) const
 {
-  GstDateTime* gstdatetime = 0;
+  GstDateTime* gstdatetime = nullptr;
   const bool has = gst_structure_get_date_time(gobj(), name.c_str(), &gstdatetime);
   if(has)
     datetime = Glib::wrap(gst_date_time_to_g_date_time(gstdatetime), false);
@@ -347,7 +347,7 @@ bool Structure::map_in_place(const SlotMap& slot)
 
 Structure Structure::create_from_string(const Glib::ustring& the_string)
 {
-  return Structure(gst_structure_from_string(the_string.c_str(), 0)); 
+  return Structure(gst_structure_from_string(the_string.c_str(), nullptr)); 
 }
 
 bool Structure::fixate_nearest_fraction(const Glib::ustring& name, const Gst::Fraction& target)
diff --git a/gstreamer/src/taglist.ccg b/gstreamer/src/taglist.ccg
index c03211a..dd3a2f6 100644
--- a/gstreamer/src/taglist.ccg
+++ b/gstreamer/src/taglist.ccg
@@ -110,7 +110,7 @@ const char* gstreamermm_get_stock_tag(Tag tag)
 
 TagList::operator bool() const
 {
-  return gobject_ != 0;
+  return gobject_ != nullptr;
 }
 
 std::ostream& operator<<(std::ostream& stream, Tag tag)
@@ -148,7 +148,7 @@ void TagList::add(Tag tag, const Glib::Date& date, TagMergeMode mode)
 
 void TagList::add(const Glib::ustring& tag, const Glib::Date& date, TagMergeMode mode)
 {
-  gst_tag_list_add(gobj(), static_cast<GstTagMergeMode>(mode), tag.c_str(), date.gobj(), NULL);
+  gst_tag_list_add(gobj(), static_cast<GstTagMergeMode>(mode), tag.c_str(), date.gobj(), nullptr);
 }
 
 void TagList::foreach(const SlotForeach& slot)
diff --git a/gstreamer/src/typefind.ccg b/gstreamer/src/typefind.ccg
index da50d90..d6a687b 100644
--- a/gstreamer/src/typefind.ccg
+++ b/gstreamer/src/typefind.ccg
@@ -71,7 +71,7 @@ bool TypeFind::register_slot(const Glib::RefPtr<Gst::Plugin>& plugin,
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
   return gst_type_find_register(Glib::unwrap(plugin), name.c_str(), rank,
-    &TypeFind_Find_gstreamermm_callback, 0, const_cast<GstCaps*>(Glib::unwrap(caps)), slot_copy,
+    &TypeFind_Find_gstreamermm_callback, nullptr, const_cast<GstCaps*>(Glib::unwrap(caps)), slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
@@ -82,7 +82,7 @@ bool TypeFind::register_slot(const Glib::RefPtr<Gst::Plugin>& plugin,
   SlotFind* slot_copy = new SlotFind(find_slot);
   return gst_type_find_register(Glib::unwrap(plugin), name.c_str(), rank,
     &TypeFind_Find_gstreamermm_callback,
-    (gchar*)extensions.data(), 0, slot_copy,
+    (gchar*)extensions.data(), nullptr, slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
@@ -91,7 +91,7 @@ bool TypeFind::register_slot(const Glib::RefPtr<Gst::Plugin>& plugin,
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
   return gst_type_find_register(Glib::unwrap(plugin), name.c_str(), rank,
-    &TypeFind_Find_gstreamermm_callback, 0, 0, slot_copy,
+    &TypeFind_Find_gstreamermm_callback, nullptr, nullptr, slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
@@ -100,7 +100,7 @@ bool TypeFind::register_slot(const Glib::ustring& name, guint rank,
   const Glib::RefPtr<const Gst::Caps>& caps)
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
-  return gst_type_find_register(0, name.c_str(), rank,
+  return gst_type_find_register(nullptr, name.c_str(), rank,
     &TypeFind_Find_gstreamermm_callback,
     (gchar*)extensions.data(), const_cast<GstCaps*>(Glib::unwrap(caps)), slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
@@ -110,8 +110,8 @@ bool TypeFind::register_slot(const Glib::ustring& name, guint rank,
   const SlotFind& find_slot, const Glib::RefPtr<const Gst::Caps>& caps)
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
-  return gst_type_find_register(0, name.c_str(), rank,
-    &TypeFind_Find_gstreamermm_callback, 0, const_cast<GstCaps*>(Glib::unwrap(caps)), slot_copy,
+  return gst_type_find_register(nullptr, name.c_str(), rank,
+    &TypeFind_Find_gstreamermm_callback, nullptr, const_cast<GstCaps*>(Glib::unwrap(caps)), slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
@@ -119,9 +119,9 @@ bool TypeFind::register_slot(const Glib::ustring& name, guint rank,
   const SlotFind& find_slot, const Glib::StringArrayHandle& extensions)
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
-  return gst_type_find_register(0, name.c_str(), rank,
+  return gst_type_find_register(nullptr, name.c_str(), rank,
     &TypeFind_Find_gstreamermm_callback,
-    (gchar*)extensions.data(), 0, slot_copy,
+    (gchar*)extensions.data(), nullptr, slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
@@ -129,8 +129,8 @@ bool TypeFind::register_slot(const Glib::ustring& name, guint rank,
   const SlotFind& find_slot)
 {
   SlotFind* slot_copy = new SlotFind(find_slot);
-  return gst_type_find_register(0, name.c_str(), rank,
-    &TypeFind_Find_gstreamermm_callback, 0, 0, slot_copy,
+  return gst_type_find_register(nullptr, name.c_str(), rank,
+    &TypeFind_Find_gstreamermm_callback, nullptr, nullptr, slot_copy,
     &TypeFind_Find_gstreamermm_callback_destroy);
 }
 
diff --git a/gstreamer/src/urihandler.ccg b/gstreamer/src/urihandler.ccg
index b5285a4..d990e1b 100644
--- a/gstreamer/src/urihandler.ccg
+++ b/gstreamer/src/urihandler.ccg
@@ -40,7 +40,7 @@ URIType URIHandler::get_type_vfunc()
 
 GstURIType URIHandler_Class::get_type_vfunc_callback(GType type)
 {
-  gpointer self = g_object_new(type, NULL);
+  gpointer self = g_object_new(type, nullptr);
   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
@@ -88,13 +88,13 @@ const gchar * const * URIHandler::get_protocols_vfunc() const
   {
     return (*base->get_protocols)(CppObjectType::get_type());
   }
-  static const gchar* protocols[] = {NULL};
+  static const gchar* protocols[] = {nullptr};
   return protocols;
 }
 
 const gchar * const * URIHandler_Class::get_protocols_vfunc_callback(GType type)
 {
-  gpointer self = g_object_new(type, NULL);
+  gpointer self = g_object_new(type, nullptr);
   Glib::ObjectBase *const obj_base = static_cast<Glib::ObjectBase*>(
       Glib::ObjectBase::_get_current_wrapper((GObject*)self));
 
@@ -127,7 +127,7 @@ const gchar * const * URIHandler_Class::get_protocols_vfunc_callback(GType type)
   {
     return (*base->get_protocols)(type);
   }
-  static const gchar *protocols[] = { NULL };
+  static const gchar *protocols[] = { nullptr };
   return protocols;
 }
 }