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


#include <glibmm.h>

#include <gtkmm/fontdialogbutton.h>
#include <gtkmm/private/fontdialogbutton_p.h>


/* Copyright (C) 2022 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
{


static const Glib::SignalProxyInfo FontDialogButton_signal_activate_info =
{
  "activate",
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback,
  (GCallback) &Glib::SignalProxyNormal::slot0_void_callback
};


} // anonymous namespace

// static
GType Glib::Value<Gtk::FontLevel>::value_type()
{
  return gtk_font_level_get_type();
}


namespace Glib
{

Gtk::FontDialogButton* wrap(GtkFontDialogButton* object, bool take_copy)
{
  return dynamic_cast<Gtk::FontDialogButton *> (Glib::wrap_auto ((GObject*)(object), take_copy));
}

} /* namespace Glib */

namespace Gtk
{


/* The *_Class implementation: */

const Glib::Class& FontDialogButton_Class::init()
{
  if(!gtype_) // create the GType if necessary
  {
    // Do not derive a GType, or use a derived class:
    gtype_ = gtk_font_dialog_button_get_type();

  }

  return *this;
}


Glib::ObjectBase* FontDialogButton_Class::wrap_new(GObject* o)
{
  return manage(new FontDialogButton((GtkFontDialogButton*)(o)));

}


/* The implementation: */

FontDialogButton::FontDialogButton(const Glib::ConstructParams& construct_params)
:
  Gtk::Widget(construct_params)
{
  }

FontDialogButton::FontDialogButton(GtkFontDialogButton* castitem)
:
  Gtk::Widget((GtkWidget*)(castitem))
{
  }


FontDialogButton::FontDialogButton(FontDialogButton&& src) noexcept
: Gtk::Widget(std::move(src))
{}

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

FontDialogButton::~FontDialogButton() noexcept
{
  destroy_();
}

FontDialogButton::CppClassType FontDialogButton::fontdialogbutton_class_; // initialize static member

GType FontDialogButton::get_type()
{
  return fontdialogbutton_class_.init().get_type();
}


GType FontDialogButton::get_base_type()
{
  return gtk_font_dialog_button_get_type();
}


FontDialogButton::FontDialogButton(const Glib::RefPtr<FontDialog>& dialog)
:
  // Mark this class as non-derived to allow C++ vfuncs to be skipped.
  Glib::ObjectBase(nullptr),
  Gtk::Widget(Glib::ConstructParams(fontdialogbutton_class_.init(), "dialog", Glib::unwrap(dialog), nullptr))
{
  

}

Glib::RefPtr<FontDialog> FontDialogButton::get_dialog()
{
  auto retvalue = Glib::wrap(gtk_font_dialog_button_get_dialog(gobj()));
  if(retvalue)
    retvalue->reference(); //The function does not do a ref for us.
  return retvalue;
}

Glib::RefPtr<const FontDialog> FontDialogButton::get_dialog() const
{
  return const_cast<FontDialogButton*>(this)->get_dialog();
}

void FontDialogButton::set_dialog(const Glib::RefPtr<FontDialog>& dialog)
{
  gtk_font_dialog_button_set_dialog(gobj(), Glib::unwrap(dialog));
}

FontLevel FontDialogButton::get_level() const
{
  return static_cast<FontLevel>(gtk_font_dialog_button_get_level(const_cast<GtkFontDialogButton*>(gobj())));
}

void FontDialogButton::set_level(FontLevel level)
{
  gtk_font_dialog_button_set_level(gobj(), static_cast<GtkFontLevel>(level));
}

Pango::FontDescription FontDialogButton::get_font_desc() const
{
  return Glib::wrap(gtk_font_dialog_button_get_font_desc(const_cast<GtkFontDialogButton*>(gobj())), true);
}

void FontDialogButton::set_font_desc(const Pango::FontDescription& font_desc)
{
  gtk_font_dialog_button_set_font_desc(gobj(), (font_desc).gobj());
}

Glib::ustring FontDialogButton::get_font_features() const
{
  return Glib::convert_const_gchar_ptr_to_ustring(gtk_font_dialog_button_get_font_features(const_cast<GtkFontDialogButton*>(gobj())));
}

void FontDialogButton::set_font_features(const Glib::ustring& font_features)
{
  gtk_font_dialog_button_set_font_features(gobj(), font_features.c_str());
}

Pango::Language FontDialogButton::get_language() const
{
  return Pango::Language(gtk_font_dialog_button_get_language(const_cast<GtkFontDialogButton*>(gobj())));
}

void FontDialogButton::set_language(const Pango::Language& language)
{
  gtk_font_dialog_button_set_language(gobj(), const_cast<PangoLanguage*>((language).gobj()));
}

bool FontDialogButton::get_use_font() const
{
  return gtk_font_dialog_button_get_use_font(const_cast<GtkFontDialogButton*>(gobj()));
}

void FontDialogButton::set_use_font(bool use_font)
{
  gtk_font_dialog_button_set_use_font(gobj(), static_cast<int>(use_font));
}

bool FontDialogButton::get_use_size() const
{
  return gtk_font_dialog_button_get_use_size(const_cast<GtkFontDialogButton*>(gobj()));
}

void FontDialogButton::set_use_size(bool use_size)
{
  gtk_font_dialog_button_set_use_size(gobj(), static_cast<int>(use_size));
}


Glib::SignalProxy<void()> FontDialogButton::signal_activate()
{
  return Glib::SignalProxy<void() >(this, &FontDialogButton_signal_activate_info);
}


static_assert(Glib::Traits::ValueCompatibleWithWrapProperty<Glib::RefPtr<FontDialog>>::value,
  "Type Glib::RefPtr<FontDialog> cannot be used in _WRAP_PROPERTY. "
  "There is no suitable template specialization of Glib::Value<>.");

Glib::PropertyProxy< Glib::RefPtr<FontDialog> > FontDialogButton::property_dialog() 
{
  return Glib::PropertyProxy< Glib::RefPtr<FontDialog> >(this, "dialog");
}

Glib::PropertyProxy_ReadOnly< Glib::RefPtr<FontDialog> > FontDialogButton::property_dialog() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::RefPtr<FontDialog> >(this, "dialog");
}

static_assert(Glib::Traits::ValueCompatibleWithWrapProperty<FontLevel>::value,
  "Type FontLevel cannot be used in _WRAP_PROPERTY. "
  "There is no suitable template specialization of Glib::Value<>.");

Glib::PropertyProxy< FontLevel > FontDialogButton::property_level() 
{
  return Glib::PropertyProxy< FontLevel >(this, "level");
}

Glib::PropertyProxy_ReadOnly< FontLevel > FontDialogButton::property_level() const
{
  return Glib::PropertyProxy_ReadOnly< FontLevel >(this, "level");
}

static_assert(Glib::Traits::ValueCompatibleWithWrapProperty<Pango::FontDescription>::value,
  "Type Pango::FontDescription cannot be used in _WRAP_PROPERTY. "
  "There is no suitable template specialization of Glib::Value<>.");

Glib::PropertyProxy< Pango::FontDescription > FontDialogButton::property_font_desc() 
{
  return Glib::PropertyProxy< Pango::FontDescription >(this, "font-desc");
}

Glib::PropertyProxy_ReadOnly< Pango::FontDescription > FontDialogButton::property_font_desc() const
{
  return Glib::PropertyProxy_ReadOnly< Pango::FontDescription >(this, "font-desc");
}

Glib::PropertyProxy< Glib::ustring > FontDialogButton::property_font_features() 
{
  return Glib::PropertyProxy< Glib::ustring >(this, "font-features");
}

Glib::PropertyProxy_ReadOnly< Glib::ustring > FontDialogButton::property_font_features() const
{
  return Glib::PropertyProxy_ReadOnly< Glib::ustring >(this, "font-features");
}

static_assert(Glib::Traits::ValueCompatibleWithWrapProperty<Pango::Language>::value,
  "Type Pango::Language cannot be used in _WRAP_PROPERTY. "
  "There is no suitable template specialization of Glib::Value<>.");

Glib::PropertyProxy< Pango::Language > FontDialogButton::property_language() 
{
  return Glib::PropertyProxy< Pango::Language >(this, "language");
}

Glib::PropertyProxy_ReadOnly< Pango::Language > FontDialogButton::property_language() const
{
  return Glib::PropertyProxy_ReadOnly< Pango::Language >(this, "language");
}

Glib::PropertyProxy< bool > FontDialogButton::property_use_font() 
{
  return Glib::PropertyProxy< bool >(this, "use-font");
}

Glib::PropertyProxy_ReadOnly< bool > FontDialogButton::property_use_font() const
{
  return Glib::PropertyProxy_ReadOnly< bool >(this, "use-font");
}

Glib::PropertyProxy< bool > FontDialogButton::property_use_size() 
{
  return Glib::PropertyProxy< bool >(this, "use-size");
}

Glib::PropertyProxy_ReadOnly< bool > FontDialogButton::property_use_size() const
{
  return Glib::PropertyProxy_ReadOnly< bool >(this, "use-size");
}


} // namespace Gtk


