// Generated by gmmproc 2.50.1 -- DO NOT MODIFY!


#include <gstreamermmconfig.h>
#ifndef GSTREAMERMM_DISABLE_DEPRECATED


#include <glibmm.h>

#include <gstreamermm/playbin.h>
#include <gstreamermm/private/playbin_p.h>


// Generated by generate_plugin_gmmproc_file. Don't edit this file.


extern "C"
{

GType gst_play_bin_gstreamermm_get_type()
{
  static GType type = 0;
  GstElementFactory* factory = 0;
  GstPluginFeature* feature = 0;

  if(!type)
  {
    factory = gst_element_factory_find("playbin");
    // Make sure that the feature is actually loaded:
    if(factory)
    {
      feature =
        gst_plugin_feature_load(GST_PLUGIN_FEATURE(factory));

      g_object_unref(factory);
      factory = GST_ELEMENT_FACTORY(feature);
      type = gst_element_factory_get_element_type(factory);
      g_object_unref(factory);
    }
  }

  return type;
}

} // extern "C"

namespace Gst
{

PlayBin::PlayBin()
: // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gst::Pipeline(Glib::ConstructParams(playbin_class_.init(), "name",static_cast<char*>(0), nullptr))
{}

PlayBin::PlayBin(const Glib::ustring& name)
: // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gst::Pipeline(Glib::ConstructParams(playbin_class_.init(), "name",name.c_str(), nullptr))
{}

Gst::TagList PlayBin::get_video_tags(int arg0)
{
  GstTagList* result;
  g_signal_emit_by_name(gobj(), "get-video-tags", arg0, &result, static_cast<void*>(0));
  return Glib::wrap_taglist(result);
}

Gst::TagList PlayBin::get_audio_tags(int arg0)
{
  GstTagList* result;
  g_signal_emit_by_name(gobj(), "get-audio-tags", arg0, &result, static_cast<void*>(0));
  return Glib::wrap_taglist(result);
}

Gst::TagList PlayBin::get_text_tags(int arg0)
{
  GstTagList* result;
  g_signal_emit_by_name(gobj(), "get-text-tags", arg0, &result, static_cast<void*>(0));
  return Glib::wrap_taglist(result);
}

Glib::RefPtr<Gst::Sample> PlayBin::convert_sample(const Glib::RefPtr<Gst::Caps>& arg0)
{
  GstSample* result;
  g_signal_emit_by_name(gobj(), "convert-sample", Glib::unwrap(arg0), &result, static_cast<void*>(0));
  return Glib::wrap(result);
}

Glib::RefPtr<Gst::Pad> PlayBin::get_video_pad(int arg0)
{
  GstPad* result;
  g_signal_emit_by_name(gobj(), "get-video-pad", arg0, &result, static_cast<void*>(0));
  return Glib::wrap(result);
}

Glib::RefPtr<Gst::Pad> PlayBin::get_audio_pad(int arg0)
{
  GstPad* result;
  g_signal_emit_by_name(gobj(), "get-audio-pad", arg0, &result, static_cast<void*>(0));
  return Glib::wrap(result);
}

Glib::RefPtr<Gst::Pad> PlayBin::get_text_pad(int arg0)
{
  GstPad* result;
  g_signal_emit_by_name(gobj(), "get-text-pad", arg0, &result, static_cast<void*>(0));
  return Glib::wrap(result);
}

}

namespace
{


static const Glib::SignalProxyInfo PlayBin_signal_about_to_finish_info =
{
  "about-to-finish",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


static const Glib::SignalProxyInfo PlayBin_signal_video_changed_info =
{
  "video-changed",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


static const Glib::SignalProxyInfo PlayBin_signal_audio_changed_info =
{
  "audio-changed",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


static const Glib::SignalProxyInfo PlayBin_signal_text_changed_info =
{
  "text-changed",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


static void PlayBin_signal_video_tags_changed_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }
}

static const Glib::SignalProxyInfo PlayBin_signal_video_tags_changed_info =
{
  "video-tags-changed",
  (GCallback) &PlayBin_signal_video_tags_changed_callback,
  (GCallback) &PlayBin_signal_video_tags_changed_callback
};


static void PlayBin_signal_audio_tags_changed_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }
}

static const Glib::SignalProxyInfo PlayBin_signal_audio_tags_changed_info =
{
  "audio-tags-changed",
  (GCallback) &PlayBin_signal_audio_tags_changed_callback,
  (GCallback) &PlayBin_signal_audio_tags_changed_callback
};


static void PlayBin_signal_text_tags_changed_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }
}

static const Glib::SignalProxyInfo PlayBin_signal_text_tags_changed_info =
{
  "text-tags-changed",
  (GCallback) &PlayBin_signal_text_tags_changed_callback,
  (GCallback) &PlayBin_signal_text_tags_changed_callback
};


static void PlayBin_signal_source_setup_callback(GstPlayBin* self, GstElement* p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,const Glib::RefPtr<Gst::Element>& >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
);
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }
}

static const Glib::SignalProxyInfo PlayBin_signal_source_setup_info =
{
  "source-setup",
  (GCallback) &PlayBin_signal_source_setup_callback,
  (GCallback) &PlayBin_signal_source_setup_callback
};


static GstTagList* PlayBin_signal_get_video_tags_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Gst::TagList,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return ((*static_cast<SlotType*>(slot))(p0
)).gobj_copy();
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static GstTagList* PlayBin_signal_get_video_tags_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_video_tags_info =
{
  "get-video-tags",
  (GCallback) &PlayBin_signal_get_video_tags_callback,
  (GCallback) &PlayBin_signal_get_video_tags_notify_callback
};


static GstTagList* PlayBin_signal_get_audio_tags_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Gst::TagList,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return ((*static_cast<SlotType*>(slot))(p0
)).gobj_copy();
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static GstTagList* PlayBin_signal_get_audio_tags_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_audio_tags_info =
{
  "get-audio-tags",
  (GCallback) &PlayBin_signal_get_audio_tags_callback,
  (GCallback) &PlayBin_signal_get_audio_tags_notify_callback
};


static GstTagList* PlayBin_signal_get_text_tags_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Gst::TagList,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return ((*static_cast<SlotType*>(slot))(p0
)).gobj_copy();
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static GstTagList* PlayBin_signal_get_text_tags_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstTagList*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_text_tags_info =
{
  "get-text-tags",
  (GCallback) &PlayBin_signal_get_text_tags_callback,
  (GCallback) &PlayBin_signal_get_text_tags_notify_callback
};


static GstSample* PlayBin_signal_convert_sample_callback(GstPlayBin* self, GstCaps* p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Glib::RefPtr<Gst::Sample>,const Glib::RefPtr<Gst::Caps>& >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return ((*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
))->gobj_copy();
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstSample*;
  return RType();
}

static GstSample* PlayBin_signal_convert_sample_notify_callback(GstPlayBin* self, GstCaps* p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,const Glib::RefPtr<Gst::Caps>& >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(Glib::wrap(p0, true)
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstSample*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_convert_sample_info =
{
  "convert-sample",
  (GCallback) &PlayBin_signal_convert_sample_callback,
  (GCallback) &PlayBin_signal_convert_sample_notify_callback
};


static GstPad* PlayBin_signal_get_video_pad_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Glib::RefPtr<Gst::Pad>,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return Glib::unwrap((*static_cast<SlotType*>(slot))(p0
));
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static GstPad* PlayBin_signal_get_video_pad_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_video_pad_info =
{
  "get-video-pad",
  (GCallback) &PlayBin_signal_get_video_pad_callback,
  (GCallback) &PlayBin_signal_get_video_pad_notify_callback
};


static GstPad* PlayBin_signal_get_audio_pad_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Glib::RefPtr<Gst::Pad>,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return Glib::unwrap((*static_cast<SlotType*>(slot))(p0
));
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static GstPad* PlayBin_signal_get_audio_pad_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_audio_pad_info =
{
  "get-audio-pad",
  (GCallback) &PlayBin_signal_get_audio_pad_callback,
  (GCallback) &PlayBin_signal_get_audio_pad_notify_callback
};


static GstPad* PlayBin_signal_get_text_pad_callback(GstPlayBin* self, gint p0,void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< Glib::RefPtr<Gst::Pad>,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        return Glib::unwrap((*static_cast<SlotType*>(slot))(p0
));
    }
    catch(...)
    {
       Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static GstPad* PlayBin_signal_get_text_pad_notify_callback(GstPlayBin* self, gint p0, void* data)
{
  using namespace Gst;
  using SlotType = sigc::slot< void,int >;

  auto obj = dynamic_cast<PlayBin*>(Glib::ObjectBase::_get_current_wrapper((GObject*) self));
  // Do not try to call a signal on a disassociated wrapper.
  if(obj)
  {
    try
    {
      if(const auto slot = Glib::SignalProxyNormal::data_to_slot(data))
        (*static_cast<SlotType*>(slot))(p0
);
    }
    catch(...)
    {
      Glib::exception_handlers_invoke();
    }
  }

  using RType = GstPad*;
  return RType();
}

static const Glib::SignalProxyInfo PlayBin_signal_get_text_pad_info =
{
  "get-text-pad",
  (GCallback) &PlayBin_signal_get_text_pad_callback,
  (GCallback) &PlayBin_signal_get_text_pad_notify_callback
};


} // anonymous namespace


namespace Glib
{

Glib::RefPtr<Gst::PlayBin> wrap(GstPlayBin* object, bool take_copy)
{
  return Glib::RefPtr<Gst::PlayBin>( dynamic_cast<Gst::PlayBin*> (Glib::wrap_auto ((GObject*)(object), take_copy)) );
  //We use dynamic_cast<> in case of multiple inheritance.
}

} /* namespace Glib */


namespace Gst
{


/* The *_Class implementation: */

const Glib::Class& PlayBin_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Glib::Class has to know the class init function to clone custom types.
    class_init_func_ = &PlayBin_Class::class_init_function;

    // This is actually just optimized away, apparently with no harm.
    // Make sure that the parent type has been created.
    //CppClassParent::CppObjectType::get_type();

    // Create the wrapper type, with the same class/instance size as the base type.
    register_derived_type(gst_play_bin_gstreamermm_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:
  Gst::StreamVolume::add_interface(get_type());
  Gst::VideoOverlay::add_interface(get_type());
  Gst::Navigation::add_interface(get_type());
  Gst::ColorBalance::add_interface(get_type());

  }

  return *this;
}


void PlayBin_Class::class_init_function(void* g_class, void* class_data)
{
  const auto klass = static_cast<BaseClassType*>(g_class);
  CppClassParent::class_init_function(klass, class_data);


}


Glib::ObjectBase* PlayBin_Class::wrap_new(GObject* object)
{
  return new PlayBin((GstPlayBin*)object);
}


/* The implementation: */

GstPlayBin* PlayBin::gobj_copy()
{
  reference();
  return gobj();
}

PlayBin::PlayBin(const Glib::ConstructParams& construct_params)
:
  Gst::Pipeline(construct_params)
{

}

PlayBin::PlayBin(GstPlayBin* castitem)
:
  Gst::Pipeline((GstPipeline*)(castitem))
{}


PlayBin::PlayBin(PlayBin&& src) noexcept
: Gst::Pipeline(std::move(src))
  , Gst::StreamVolume(std::move(src))
  , Gst::VideoOverlay(std::move(src))
  , Gst::Navigation(std::move(src))
  , Gst::ColorBalance(std::move(src))
{}

PlayBin& PlayBin::operator=(PlayBin&& src) noexcept
{
  Gst::Pipeline::operator=(std::move(src));
  Gst::StreamVolume::operator=(std::move(src));
  Gst::VideoOverlay::operator=(std::move(src));
  Gst::Navigation::operator=(std::move(src));
  Gst::ColorBalance::operator=(std::move(src));
  return *this;
}


PlayBin::~PlayBin() noexcept
{}


PlayBin::CppClassType PlayBin::playbin_class_; // initialize static member

GType PlayBin::get_type()
{
  return playbin_class_.init().get_type();
}


GType PlayBin::get_base_type()
{
  return gst_play_bin_gstreamermm_get_type();
}


Glib::RefPtr<PlayBin> PlayBin::create()
{
  return Glib::RefPtr<PlayBin>( new PlayBin() );
}

Glib::RefPtr<PlayBin> PlayBin::create(const Glib::ustring& name)
{
  return Glib::RefPtr<PlayBin>( new PlayBin(name) );
}


Glib::SignalProxy< void > PlayBin::signal_about_to_finish()
{
  return Glib::SignalProxy< void >(this, &PlayBin_signal_about_to_finish_info);
}


Glib::SignalProxy< void > PlayBin::signal_video_changed()
{
  return Glib::SignalProxy< void >(this, &PlayBin_signal_video_changed_info);
}


Glib::SignalProxy< void > PlayBin::signal_audio_changed()
{
  return Glib::SignalProxy< void >(this, &PlayBin_signal_audio_changed_info);
}


Glib::SignalProxy< void > PlayBin::signal_text_changed()
{
  return Glib::SignalProxy< void >(this, &PlayBin_signal_text_changed_info);
}


Glib::SignalProxy< void,int > PlayBin::signal_video_tags_changed()
{
  return Glib::SignalProxy< void,int >(this, &PlayBin_signal_video_tags_changed_info);
}


Glib::SignalProxy< void,int > PlayBin::signal_audio_tags_changed()
{
  return Glib::SignalProxy< void,int >(this, &PlayBin_signal_audio_tags_changed_info);
}


Glib::SignalProxy< void,int > PlayBin::signal_text_tags_changed()
{
  return Glib::SignalProxy< void,int >(this, &PlayBin_signal_text_tags_changed_info);
}


Glib::SignalProxy< void,const Glib::RefPtr<Gst::Element>& > PlayBin::signal_source_setup()
{
  return Glib::SignalProxy< void,const Glib::RefPtr<Gst::Element>& >(this, &PlayBin_signal_source_setup_info);
}


Glib::SignalProxy< Gst::TagList,int > PlayBin::signal_get_video_tags()
{
  return Glib::SignalProxy< Gst::TagList,int >(this, &PlayBin_signal_get_video_tags_info);
}


Glib::SignalProxy< Gst::TagList,int > PlayBin::signal_get_audio_tags()
{
  return Glib::SignalProxy< Gst::TagList,int >(this, &PlayBin_signal_get_audio_tags_info);
}


Glib::SignalProxy< Gst::TagList,int > PlayBin::signal_get_text_tags()
{
  return Glib::SignalProxy< Gst::TagList,int >(this, &PlayBin_signal_get_text_tags_info);
}


Glib::SignalProxy< Glib::RefPtr<Gst::Sample>,const Glib::RefPtr<Gst::Caps>& > PlayBin::signal_convert_sample()
{
  return Glib::SignalProxy< Glib::RefPtr<Gst::Sample>,const Glib::RefPtr<Gst::Caps>& >(this, &PlayBin_signal_convert_sample_info);
}


Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int > PlayBin::signal_get_video_pad()
{
  return Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int >(this, &PlayBin_signal_get_video_pad_info);
}


Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int > PlayBin::signal_get_audio_pad()
{
  return Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int >(this, &PlayBin_signal_get_audio_pad_info);
}


Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int > PlayBin::signal_get_text_pad()
{
  return Glib::SignalProxy< Glib::RefPtr<Gst::Pad>,int >(this, &PlayBin_signal_get_text_pad_info);
}


Glib::PropertyProxy< Glib::ustring > PlayBin::property_uri() 
{
  return Glib::PropertyProxy< Glib::ustring >(this, "uri");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > PlayBin::property_uri() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "uri");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > PlayBin::property_current_uri() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "current-uri");
}

Glib::PropertyProxy< Glib::ustring > PlayBin::property_suburi() 
{
  return Glib::PropertyProxy< Glib::ustring >(this, "suburi");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > PlayBin::property_suburi() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "suburi");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > PlayBin::property_current_suburi() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "current-suburi");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_source() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "source");
}

Glib::PropertyProxy< Gst::PlayFlags > PlayBin::property_flags() 
{
  return Glib::PropertyProxy< Gst::PlayFlags >(this, "flags");
}

Glib::PropertyProxy_ReadOnly< Gst::PlayFlags > PlayBin::property_flags() const
{
  return Glib::PropertyProxy_ReadOnly< Gst::PlayFlags >(this, "flags");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_n_video() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "n-video");
}

Glib::PropertyProxy< int > PlayBin::property_current_video() 
{
  return Glib::PropertyProxy< int >(this, "current-video");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_current_video() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "current-video");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_n_audio() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "n-audio");
}

Glib::PropertyProxy< int > PlayBin::property_current_audio() 
{
  return Glib::PropertyProxy< int >(this, "current-audio");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_current_audio() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "current-audio");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_n_text() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "n-text");
}

Glib::PropertyProxy< int > PlayBin::property_current_text() 
{
  return Glib::PropertyProxy< int >(this, "current-text");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_current_text() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "current-text");
}

Glib::PropertyProxy< Glib::ustring > PlayBin::property_subtitle_encoding() 
{
  return Glib::PropertyProxy< Glib::ustring >(this, "subtitle-encoding");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > PlayBin::property_subtitle_encoding() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "subtitle-encoding");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_sink() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "audio-sink");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_sink() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "audio-sink");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_video_sink() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "video-sink");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_video_sink() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "video-sink");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_vis_plugin() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "vis-plugin");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_vis_plugin() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "vis-plugin");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_text_sink() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "text-sink");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_text_sink() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "text-sink");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_video_stream_combiner() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "video-stream-combiner");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_video_stream_combiner() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "video-stream-combiner");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_stream_combiner() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "audio-stream-combiner");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_stream_combiner() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "audio-stream-combiner");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_text_stream_combiner() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "text-stream-combiner");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_text_stream_combiner() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "text-stream-combiner");
}

Glib::PropertyProxy< double > PlayBin::property_volume() 
{
  return Glib::PropertyProxy< double >(this, "volume");
}

Glib::PropertyProxy_ReadOnly< double > PlayBin::property_volume() const
{
  return Glib::PropertyProxy_ReadOnly< double >(this, "volume");
}

Glib::PropertyProxy< bool > PlayBin::property_mute() 
{
  return Glib::PropertyProxy< bool >(this, "mute");
}

Glib::PropertyProxy_ReadOnly< bool > PlayBin::property_mute() const
{
  return Glib::PropertyProxy_ReadOnly< bool >(this, "mute");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Sample> > PlayBin::property_sample() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Sample> >(this, "sample");
}

Glib::PropertyProxy_WriteOnly< Glib::ustring > PlayBin::property_subtitle_font_desc() 
{
  return Glib::PropertyProxy_WriteOnly< Glib::ustring >(this, "subtitle-font-desc");
}

Glib::PropertyProxy< guint64 > PlayBin::property_connection_speed() 
{
  return Glib::PropertyProxy< guint64 >(this, "connection-speed");
}

Glib::PropertyProxy_ReadOnly< guint64 > PlayBin::property_connection_speed() const
{
  return Glib::PropertyProxy_ReadOnly< guint64 >(this, "connection-speed");
}

Glib::PropertyProxy< int > PlayBin::property_buffer_size() 
{
  return Glib::PropertyProxy< int >(this, "buffer-size");
}

Glib::PropertyProxy_ReadOnly< int > PlayBin::property_buffer_size() const
{
  return Glib::PropertyProxy_ReadOnly< int >(this, "buffer-size");
}

Glib::PropertyProxy< gint64 > PlayBin::property_buffer_duration() 
{
  return Glib::PropertyProxy< gint64 >(this, "buffer-duration");
}

Glib::PropertyProxy_ReadOnly< gint64 > PlayBin::property_buffer_duration() const
{
  return Glib::PropertyProxy_ReadOnly< gint64 >(this, "buffer-duration");
}

Glib::PropertyProxy< gint64 > PlayBin::property_av_offset() 
{
  return Glib::PropertyProxy< gint64 >(this, "av-offset");
}

Glib::PropertyProxy_ReadOnly< gint64 > PlayBin::property_av_offset() const
{
  return Glib::PropertyProxy_ReadOnly< gint64 >(this, "av-offset");
}

Glib::PropertyProxy< guint64 > PlayBin::property_ring_buffer_max_size() 
{
  return Glib::PropertyProxy< guint64 >(this, "ring-buffer-max-size");
}

Glib::PropertyProxy_ReadOnly< guint64 > PlayBin::property_ring_buffer_max_size() const
{
  return Glib::PropertyProxy_ReadOnly< guint64 >(this, "ring-buffer-max-size");
}

Glib::PropertyProxy< bool > PlayBin::property_force_aspect_ratio() 
{
  return Glib::PropertyProxy< bool >(this, "force-aspect-ratio");
}

Glib::PropertyProxy_ReadOnly< bool > PlayBin::property_force_aspect_ratio() const
{
  return Glib::PropertyProxy_ReadOnly< bool >(this, "force-aspect-ratio");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_filter() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "audio-filter");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_audio_filter() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "audio-filter");
}

Glib::PropertyProxy< Glib::RefPtr<Gst::Element> > PlayBin::property_video_filter() 
{
  return Glib::PropertyProxy< Glib::RefPtr<Gst::Element> >(this, "video-filter");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> > PlayBin::property_video_filter() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gst::Element> >(this, "video-filter");
}

Glib::PropertyProxy< Gst::VideoMultiviewFramePacking > PlayBin::property_video_multiview_mode() 
{
  return Glib::PropertyProxy< Gst::VideoMultiviewFramePacking >(this, "video-multiview-mode");
}

Glib::PropertyProxy_ReadOnly< Gst::VideoMultiviewFramePacking > PlayBin::property_video_multiview_mode() const
{
  return Glib::PropertyProxy_ReadOnly< Gst::VideoMultiviewFramePacking >(this, "video-multiview-mode");
}

Glib::PropertyProxy< Gst::VideoMultiviewFlags > PlayBin::property_video_multiview_flags() 
{
  return Glib::PropertyProxy< Gst::VideoMultiviewFlags >(this, "video-multiview-flags");
}

Glib::PropertyProxy_ReadOnly< Gst::VideoMultiviewFlags > PlayBin::property_video_multiview_flags() const
{
  return Glib::PropertyProxy_ReadOnly< Gst::VideoMultiviewFlags >(this, "video-multiview-flags");
}


} // namespace Gst

#endif // GSTREAMERMM_DISABLE_DEPRECATED


