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


#include <glibmm.h>

#include <gtkmm/multifilter.h>
#include <gtkmm/private/multifilter_p.h>


/* Copyright (C) 2020 The gtkmm Development Team
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
 */

#include <gtk/gtk.h>

namespace
{
} // anonymous namespace


namespace Glib
{

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

} /* namespace Glib */


namespace Gtk
{


/* The *_Class implementation: */

const Glib::Class& MultiFilter_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_ = &MultiFilter_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(gtk_multi_filter_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:
  Gio::ListModel::add_interface(get_type());
  Buildable::add_interface(get_type());

  }

  return *this;
}


void MultiFilter_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* MultiFilter_Class::wrap_new(GObject* object)
{
  return new MultiFilter((GtkMultiFilter*)object);
}


/* The implementation: */

GtkMultiFilter* MultiFilter::gobj_copy()
{
  reference();
  return gobj();
}

MultiFilter::MultiFilter(const Glib::ConstructParams& construct_params)
:
  Gtk::Filter(construct_params)
{

}

MultiFilter::MultiFilter(GtkMultiFilter* castitem)
:
  Gtk::Filter((GtkFilter*)(castitem))
{}


MultiFilter::MultiFilter(MultiFilter&& src) noexcept
: Gtk::Filter(std::move(src))
  , Gio::ListModel(std::move(src))
  , Buildable(std::move(src))
{}

MultiFilter& MultiFilter::operator=(MultiFilter&& src) noexcept
{
  Gtk::Filter::operator=(std::move(src));
  Gio::ListModel::operator=(std::move(src));
  Buildable::operator=(std::move(src));
  return *this;
}


MultiFilter::~MultiFilter() noexcept
{}


MultiFilter::CppClassType MultiFilter::multifilter_class_; // initialize static member

GType MultiFilter::get_type()
{
  return multifilter_class_.init().get_type();
}


GType MultiFilter::get_base_type()
{
  return gtk_multi_filter_get_type();
}


MultiFilter::MultiFilter()
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gtk::Filter(Glib::ConstructParams(multifilter_class_.init()))
{
  

}

void MultiFilter::append(const Glib::RefPtr<Filter>& filter)
{
  gtk_multi_filter_append(gobj(), Glib::unwrap_copy(filter));
}

void MultiFilter::remove(guint position)
{
  gtk_multi_filter_remove(gobj(), position);
}


} // namespace Gtk


namespace Glib
{

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

} /* namespace Glib */


namespace Gtk
{


/* The *_Class implementation: */

const Glib::Class& AnyFilter_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_ = &AnyFilter_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(gtk_any_filter_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void AnyFilter_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* AnyFilter_Class::wrap_new(GObject* object)
{
  return new AnyFilter((GtkAnyFilter*)object);
}


/* The implementation: */

GtkAnyFilter* AnyFilter::gobj_copy()
{
  reference();
  return gobj();
}

AnyFilter::AnyFilter(const Glib::ConstructParams& construct_params)
:
  Gtk::MultiFilter(construct_params)
{

}

AnyFilter::AnyFilter(GtkAnyFilter* castitem)
:
  Gtk::MultiFilter((GtkMultiFilter*)(castitem))
{}


AnyFilter::AnyFilter(AnyFilter&& src) noexcept
: Gtk::MultiFilter(std::move(src))
{}

AnyFilter& AnyFilter::operator=(AnyFilter&& src) noexcept
{
  Gtk::MultiFilter::operator=(std::move(src));
  return *this;
}


AnyFilter::~AnyFilter() noexcept
{}


AnyFilter::CppClassType AnyFilter::anyfilter_class_; // initialize static member

GType AnyFilter::get_type()
{
  return anyfilter_class_.init().get_type();
}


GType AnyFilter::get_base_type()
{
  return gtk_any_filter_get_type();
}

AnyFilter::AnyFilter()
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gtk::MultiFilter(Glib::ConstructParams(anyfilter_class_.init()))
{
  

}

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


} // namespace Gtk


namespace Glib
{

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

} /* namespace Glib */


namespace Gtk
{


/* The *_Class implementation: */

const Glib::Class& EveryFilter_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_ = &EveryFilter_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(gtk_every_filter_get_type());

    // Add derived versions of interfaces, if the C type implements any interfaces:

  }

  return *this;
}


void EveryFilter_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* EveryFilter_Class::wrap_new(GObject* object)
{
  return new EveryFilter((GtkEveryFilter*)object);
}


/* The implementation: */

GtkEveryFilter* EveryFilter::gobj_copy()
{
  reference();
  return gobj();
}

EveryFilter::EveryFilter(const Glib::ConstructParams& construct_params)
:
  Gtk::MultiFilter(construct_params)
{

}

EveryFilter::EveryFilter(GtkEveryFilter* castitem)
:
  Gtk::MultiFilter((GtkMultiFilter*)(castitem))
{}


EveryFilter::EveryFilter(EveryFilter&& src) noexcept
: Gtk::MultiFilter(std::move(src))
{}

EveryFilter& EveryFilter::operator=(EveryFilter&& src) noexcept
{
  Gtk::MultiFilter::operator=(std::move(src));
  return *this;
}


EveryFilter::~EveryFilter() noexcept
{}


EveryFilter::CppClassType EveryFilter::everyfilter_class_; // initialize static member

GType EveryFilter::get_type()
{
  return everyfilter_class_.init().get_type();
}


GType EveryFilter::get_base_type()
{
  return gtk_every_filter_get_type();
}

EveryFilter::EveryFilter()
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gtk::MultiFilter(Glib::ConstructParams(everyfilter_class_.init()))
{
  

}

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


} // namespace Gtk


