
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2026 Matthias Koefferlein

  This program is free software; you can redistribute it and/or modify
  it under the terms of the GNU General Public License as published by
  the Free Software Foundation; either version 2 of the License, or
  (at your option) any later version.

  This program 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 General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

/**
*  @file gsiDeclQIconEngine.cc 
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#include <QIconEngine>
#include <QDataStream>
#include <QPainter>
#include <QPixmap>
#include <QRect>
#include <QSize>
#include "gsiQt.h"
#include "gsiQtGuiCommon.h"
#include <memory>

// -----------------------------------------------------------------------
// class QIconEngine

// QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)


static void _init_f_actualSize_4543 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("size");
  decl->add_arg<const QSize & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<QSize > ();
}

static void _call_f_actualSize_4543 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QSize &arg1 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  ret.write<QSize > ((QSize)((QIconEngine *)cls)->actualSize (arg1, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg2).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg3).cref()));
}


// void QIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)


static void _init_f_addFile_6460 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("fileName");
  decl->add_arg<const QString & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("size");
  decl->add_arg<const QSize & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_3);
  decl->set_return<void > ();
}

static void _call_f_addFile_6460 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QString &arg1 = gsi::arg_reader<const QString & >() (args, heap);
  const QSize &arg2 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg4 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine *)cls)->addFile (arg1, arg2, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg3).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg4).cref());
}


// void QIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)


static void _init_f_addPixmap_4755 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pixmap");
  decl->add_arg<const QPixmap & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<void > ();
}

static void _call_f_addPixmap_4755 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QPixmap &arg1 = gsi::arg_reader<const QPixmap & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine *)cls)->addPixmap (arg1, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg2).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg3).cref());
}


// QList<QSize> QIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)


static void _init_f_availableSizes_c2846 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("mode", true, "QIcon::Normal");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("state", true, "QIcon::Off");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_1);
  decl->set_return<QList<QSize> > ();
}

static void _call_f_availableSizes_c2846 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg1 = args ? gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QIcon::Mode>(heap, QIcon::Normal), heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg2 = args ? gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QIcon::State>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QIcon::State>(heap, QIcon::Off), heap);
  ret.write<QList<QSize> > ((QList<QSize>)((QIconEngine *)cls)->availableSizes (qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg1).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg2).cref()));
}


// QIconEngine *QIconEngine::clone()


static void _init_f_clone_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QIconEngine * > ();
}

static void _call_f_clone_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QIconEngine * > ((QIconEngine *)((QIconEngine *)cls)->clone ());
}


// QString QIconEngine::iconName()


static void _init_f_iconName_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_f_iconName_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QString > ((QString)((QIconEngine *)cls)->iconName ());
}


// bool QIconEngine::isNull()


static void _init_f_isNull_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<bool > ();
}

static void _call_f_isNull_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<bool > ((bool)((QIconEngine *)cls)->isNull ());
}


// QString QIconEngine::key()


static void _init_f_key_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_f_key_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QString > ((QString)((QIconEngine *)cls)->key ());
}


// void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)


static void _init_f_paint_5848 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("painter");
  decl->add_arg<QPainter * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("rect");
  decl->add_arg<const QRect & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_3);
  decl->set_return<void > ();
}

static void _call_f_paint_5848 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QPainter *arg1 = gsi::arg_reader<QPainter * >() (args, heap);
  const QRect &arg2 = gsi::arg_reader<const QRect & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg4 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine *)cls)->paint (arg1, arg2, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg3).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg4).cref());
}


// QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)


static void _init_f_pixmap_4543 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("size");
  decl->add_arg<const QSize & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<QPixmap > ();
}

static void _call_f_pixmap_4543 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QSize &arg1 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  ret.write<QPixmap > ((QPixmap)((QIconEngine *)cls)->pixmap (arg1, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg2).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg3).cref()));
}


// bool QIconEngine::read(QDataStream &in)


static void _init_f_read_1697 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("in");
  decl->add_arg<QDataStream & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_f_read_1697 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QDataStream &arg1 = gsi::arg_reader<QDataStream & >() (args, heap);
  ret.write<bool > ((bool)((QIconEngine *)cls)->read (arg1));
}


// QPixmap QIconEngine::scaledPixmap(const QSize &size, QIcon::Mode mode, QIcon::State state, double scale)


static void _init_f_scaledPixmap_5506 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("size");
  decl->add_arg<const QSize & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("scale");
  decl->add_arg<double > (argspec_3);
  decl->set_return<QPixmap > ();
}

static void _call_f_scaledPixmap_5506 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QSize &arg1 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  double arg4 = gsi::arg_reader<double >() (args, heap);
  ret.write<QPixmap > ((QPixmap)((QIconEngine *)cls)->scaledPixmap (arg1, qt_gsi::QtToCppAdaptor<QIcon::Mode>(arg2).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(arg3).cref(), arg4));
}


// void QIconEngine::virtual_hook(int id, void *data)


static void _init_f_virtual_hook_1715 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("id");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("data");
  decl->add_arg<void * > (argspec_1);
  decl->set_return<void > ();
}

static void _call_f_virtual_hook_1715 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  int arg1 = gsi::arg_reader<int >() (args, heap);
  void *arg2 = gsi::arg_reader<void * >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine *)cls)->virtual_hook (arg1, arg2);
}


// bool QIconEngine::write(QDataStream &out)


static void _init_f_write_c1697 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("out");
  decl->add_arg<QDataStream & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_f_write_c1697 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QDataStream &arg1 = gsi::arg_reader<QDataStream & >() (args, heap);
  ret.write<bool > ((bool)((QIconEngine *)cls)->write (arg1));
}


namespace gsi
{

static gsi::Methods methods_QIconEngine () {
  gsi::Methods methods;
  methods += new qt_gsi::GenericMethod ("actualSize", "@brief Method QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)\n", false, &_init_f_actualSize_4543, &_call_f_actualSize_4543);
  methods += new qt_gsi::GenericMethod ("addFile", "@brief Method void QIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)\n", false, &_init_f_addFile_6460, &_call_f_addFile_6460);
  methods += new qt_gsi::GenericMethod ("addPixmap", "@brief Method void QIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)\n", false, &_init_f_addPixmap_4755, &_call_f_addPixmap_4755);
  methods += new qt_gsi::GenericMethod ("availableSizes", "@brief Method QList<QSize> QIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)\n", true, &_init_f_availableSizes_c2846, &_call_f_availableSizes_c2846);
  methods += new qt_gsi::GenericMethod ("clone", "@brief Method QIconEngine *QIconEngine::clone()\n", true, &_init_f_clone_c0, &_call_f_clone_c0);
  methods += new qt_gsi::GenericMethod ("iconName", "@brief Method QString QIconEngine::iconName()\n", true, &_init_f_iconName_c0, &_call_f_iconName_c0);
  methods += new qt_gsi::GenericMethod ("isNull?", "@brief Method bool QIconEngine::isNull()\n", true, &_init_f_isNull_c0, &_call_f_isNull_c0);
  methods += new qt_gsi::GenericMethod ("key", "@brief Method QString QIconEngine::key()\n", true, &_init_f_key_c0, &_call_f_key_c0);
  methods += new qt_gsi::GenericMethod ("paint", "@brief Method void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)\n", false, &_init_f_paint_5848, &_call_f_paint_5848);
  methods += new qt_gsi::GenericMethod ("pixmap", "@brief Method QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)\n", false, &_init_f_pixmap_4543, &_call_f_pixmap_4543);
  methods += new qt_gsi::GenericMethod ("read", "@brief Method bool QIconEngine::read(QDataStream &in)\n", false, &_init_f_read_1697, &_call_f_read_1697);
  methods += new qt_gsi::GenericMethod ("scaledPixmap", "@brief Method QPixmap QIconEngine::scaledPixmap(const QSize &size, QIcon::Mode mode, QIcon::State state, double scale)\n", false, &_init_f_scaledPixmap_5506, &_call_f_scaledPixmap_5506);
  methods += new qt_gsi::GenericMethod ("virtual_hook", "@brief Method void QIconEngine::virtual_hook(int id, void *data)\n", false, &_init_f_virtual_hook_1715, &_call_f_virtual_hook_1715);
  methods += new qt_gsi::GenericMethod ("write", "@brief Method bool QIconEngine::write(QDataStream &out)\n", true, &_init_f_write_c1697, &_call_f_write_c1697);
  return methods;
}

gsi::Class<QIconEngine> decl_QIconEngine ("QtGui", "QIconEngine_Native",
  methods_QIconEngine (),
  "@hide\n@alias QIconEngine");

GSI_QTGUI_PUBLIC gsi::Class<QIconEngine> &qtdecl_QIconEngine () { return decl_QIconEngine; }

}


class QIconEngine_Adaptor : public QIconEngine, public qt_gsi::QtObjectBase
{
public:

  virtual ~QIconEngine_Adaptor();

  //  [adaptor ctor] QIconEngine::QIconEngine()
  QIconEngine_Adaptor() : QIconEngine()
  {
    qt_gsi::QtObjectBase::init (this);
  }

  //  [adaptor ctor] QIconEngine::QIconEngine(const QIconEngine &other)
  QIconEngine_Adaptor(const QIconEngine &other) : QIconEngine(other)
  {
    qt_gsi::QtObjectBase::init (this);
  }

  //  [adaptor impl] QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
  QSize cbs_actualSize_4543_0(const QSize &size, const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state)
  {
    return QIconEngine::actualSize(size, qt_gsi::QtToCppAdaptor<QIcon::Mode>(mode).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(state).cref());
  }

  virtual QSize actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)
  {
    if (cb_actualSize_4543_0.can_issue()) {
      return cb_actualSize_4543_0.issue<QIconEngine_Adaptor, QSize, const QSize &, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_actualSize_4543_0, size, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      return QIconEngine::actualSize(size, mode, state);
    }
  }

  //  [adaptor impl] void QIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)
  void cbs_addFile_6460_0(const QString &fileName, const QSize &size, const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state)
  {
    QIconEngine::addFile(fileName, size, qt_gsi::QtToCppAdaptor<QIcon::Mode>(mode).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(state).cref());
  }

  virtual void addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)
  {
    if (cb_addFile_6460_0.can_issue()) {
      cb_addFile_6460_0.issue<QIconEngine_Adaptor, const QString &, const QSize &, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_addFile_6460_0, fileName, size, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      QIconEngine::addFile(fileName, size, mode, state);
    }
  }

  //  [adaptor impl] void QIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
  void cbs_addPixmap_4755_0(const QPixmap &pixmap, const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state)
  {
    QIconEngine::addPixmap(pixmap, qt_gsi::QtToCppAdaptor<QIcon::Mode>(mode).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(state).cref());
  }

  virtual void addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)
  {
    if (cb_addPixmap_4755_0.can_issue()) {
      cb_addPixmap_4755_0.issue<QIconEngine_Adaptor, const QPixmap &, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_addPixmap_4755_0, pixmap, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      QIconEngine::addPixmap(pixmap, mode, state);
    }
  }

  //  [adaptor impl] QList<QSize> QIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)
  QList<QSize> cbs_availableSizes_c2846_2(const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state) const
  {
    return QIconEngine::availableSizes(qt_gsi::QtToCppAdaptor<QIcon::Mode>(mode).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(state).cref());
  }

  virtual QList<QSize> availableSizes(QIcon::Mode mode, QIcon::State state) const
  {
    if (cb_availableSizes_c2846_2.can_issue()) {
      return cb_availableSizes_c2846_2.issue<QIconEngine_Adaptor, QList<QSize>, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_availableSizes_c2846_2, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      return QIconEngine::availableSizes(mode, state);
    }
  }

  //  [adaptor impl] QIconEngine *QIconEngine::clone()
  QIconEngine * cbs_clone_c0_0() const
  {
    throw qt_gsi::AbstractMethodCalledException("clone");
  }

  virtual QIconEngine * clone() const
  {
    if (cb_clone_c0_0.can_issue()) {
      return cb_clone_c0_0.issue<QIconEngine_Adaptor, QIconEngine *>(&QIconEngine_Adaptor::cbs_clone_c0_0);
    } else {
      throw qt_gsi::AbstractMethodCalledException("clone");
    }
  }

  //  [adaptor impl] QString QIconEngine::iconName()
  QString cbs_iconName_c0_0() const
  {
    return QIconEngine::iconName();
  }

  virtual QString iconName() const
  {
    if (cb_iconName_c0_0.can_issue()) {
      return cb_iconName_c0_0.issue<QIconEngine_Adaptor, QString>(&QIconEngine_Adaptor::cbs_iconName_c0_0);
    } else {
      return QIconEngine::iconName();
    }
  }

  //  [adaptor impl] QString QIconEngine::key()
  QString cbs_key_c0_0() const
  {
    return QIconEngine::key();
  }

  virtual QString key() const
  {
    if (cb_key_c0_0.can_issue()) {
      return cb_key_c0_0.issue<QIconEngine_Adaptor, QString>(&QIconEngine_Adaptor::cbs_key_c0_0);
    } else {
      return QIconEngine::key();
    }
  }

  //  [adaptor impl] void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
  void cbs_paint_5848_0(QPainter *painter, const QRect &rect, const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state)
  {
    __SUPPRESS_UNUSED_WARNING (painter);
    __SUPPRESS_UNUSED_WARNING (rect);
    __SUPPRESS_UNUSED_WARNING (mode);
    __SUPPRESS_UNUSED_WARNING (state);
    throw qt_gsi::AbstractMethodCalledException("paint");
  }

  virtual void paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)
  {
    if (cb_paint_5848_0.can_issue()) {
      cb_paint_5848_0.issue<QIconEngine_Adaptor, QPainter *, const QRect &, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_paint_5848_0, painter, rect, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      throw qt_gsi::AbstractMethodCalledException("paint");
    }
  }

  //  [adaptor impl] QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
  QPixmap cbs_pixmap_4543_0(const QSize &size, const qt_gsi::Converter<QIcon::Mode>::target_type & mode, const qt_gsi::Converter<QIcon::State>::target_type & state)
  {
    return QIconEngine::pixmap(size, qt_gsi::QtToCppAdaptor<QIcon::Mode>(mode).cref(), qt_gsi::QtToCppAdaptor<QIcon::State>(state).cref());
  }

  virtual QPixmap pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)
  {
    if (cb_pixmap_4543_0.can_issue()) {
      return cb_pixmap_4543_0.issue<QIconEngine_Adaptor, QPixmap, const QSize &, const qt_gsi::Converter<QIcon::Mode>::target_type &, const qt_gsi::Converter<QIcon::State>::target_type &>(&QIconEngine_Adaptor::cbs_pixmap_4543_0, size, qt_gsi::CppToQtAdaptor<QIcon::Mode>(mode), qt_gsi::CppToQtAdaptor<QIcon::State>(state));
    } else {
      return QIconEngine::pixmap(size, mode, state);
    }
  }

  //  [adaptor impl] bool QIconEngine::read(QDataStream &in)
  bool cbs_read_1697_0(QDataStream &in)
  {
    return QIconEngine::read(in);
  }

  virtual bool read(QDataStream &in)
  {
    if (cb_read_1697_0.can_issue()) {
      return cb_read_1697_0.issue<QIconEngine_Adaptor, bool, QDataStream &>(&QIconEngine_Adaptor::cbs_read_1697_0, in);
    } else {
      return QIconEngine::read(in);
    }
  }

  //  [adaptor impl] void QIconEngine::virtual_hook(int id, void *data)
  void cbs_virtual_hook_1715_0(int id, void *data)
  {
    QIconEngine::virtual_hook(id, data);
  }

  virtual void virtual_hook(int id, void *data)
  {
    if (cb_virtual_hook_1715_0.can_issue()) {
      cb_virtual_hook_1715_0.issue<QIconEngine_Adaptor, int, void *>(&QIconEngine_Adaptor::cbs_virtual_hook_1715_0, id, data);
    } else {
      QIconEngine::virtual_hook(id, data);
    }
  }

  //  [adaptor impl] bool QIconEngine::write(QDataStream &out)
  bool cbs_write_c1697_0(QDataStream &out) const
  {
    return QIconEngine::write(out);
  }

  virtual bool write(QDataStream &out) const
  {
    if (cb_write_c1697_0.can_issue()) {
      return cb_write_c1697_0.issue<QIconEngine_Adaptor, bool, QDataStream &>(&QIconEngine_Adaptor::cbs_write_c1697_0, out);
    } else {
      return QIconEngine::write(out);
    }
  }

  gsi::Callback cb_actualSize_4543_0;
  gsi::Callback cb_addFile_6460_0;
  gsi::Callback cb_addPixmap_4755_0;
  gsi::Callback cb_availableSizes_c2846_2;
  gsi::Callback cb_clone_c0_0;
  gsi::Callback cb_iconName_c0_0;
  gsi::Callback cb_key_c0_0;
  gsi::Callback cb_paint_5848_0;
  gsi::Callback cb_pixmap_4543_0;
  gsi::Callback cb_read_1697_0;
  gsi::Callback cb_virtual_hook_1715_0;
  gsi::Callback cb_write_c1697_0;
};

QIconEngine_Adaptor::~QIconEngine_Adaptor() { }

//  Constructor QIconEngine::QIconEngine() (adaptor class)

static void _init_ctor_QIconEngine_Adaptor_0 (qt_gsi::GenericStaticMethod *decl)
{
  decl->set_return_new<QIconEngine_Adaptor> ();
}

static void _call_ctor_QIconEngine_Adaptor_0 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QIconEngine_Adaptor *> (new QIconEngine_Adaptor ());
}


//  Constructor QIconEngine::QIconEngine(const QIconEngine &other) (adaptor class)

static void _init_ctor_QIconEngine_Adaptor_2385 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QIconEngine & > (argspec_0);
  decl->set_return_new<QIconEngine_Adaptor> ();
}

static void _call_ctor_QIconEngine_Adaptor_2385 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QIconEngine &arg1 = gsi::arg_reader<const QIconEngine & >() (args, heap);
  ret.write<QIconEngine_Adaptor *> (new QIconEngine_Adaptor (arg1));
}


// QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)

static void _init_cbs_actualSize_4543_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("size");
  decl->add_arg<const QSize & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<QSize > ();
}

static void _call_cbs_actualSize_4543_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QSize &arg1 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  ret.write<QSize > ((QSize)((QIconEngine_Adaptor *)cls)->cbs_actualSize_4543_0 (arg1, arg2, arg3));
}

static void _set_callback_cbs_actualSize_4543_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_actualSize_4543_0 = cb;
}


// void QIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)

static void _init_cbs_addFile_6460_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("fileName");
  decl->add_arg<const QString & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("size");
  decl->add_arg<const QSize & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_3);
  decl->set_return<void > ();
}

static void _call_cbs_addFile_6460_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QString &arg1 = gsi::arg_reader<const QString & >() (args, heap);
  const QSize &arg2 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg4 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine_Adaptor *)cls)->cbs_addFile_6460_0 (arg1, arg2, arg3, arg4);
}

static void _set_callback_cbs_addFile_6460_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_addFile_6460_0 = cb;
}


// void QIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)

static void _init_cbs_addPixmap_4755_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("pixmap");
  decl->add_arg<const QPixmap & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<void > ();
}

static void _call_cbs_addPixmap_4755_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QPixmap &arg1 = gsi::arg_reader<const QPixmap & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine_Adaptor *)cls)->cbs_addPixmap_4755_0 (arg1, arg2, arg3);
}

static void _set_callback_cbs_addPixmap_4755_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_addPixmap_4755_0 = cb;
}


// QList<QSize> QIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)

static void _init_cbs_availableSizes_c2846_2 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_1);
  decl->set_return<QList<QSize> > ();
}

static void _call_cbs_availableSizes_c2846_2 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg1 = args ? gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QIcon::Mode>(heap, QIcon::Normal), heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg2 = args ? gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap) : gsi::arg_maker<const qt_gsi::Converter<QIcon::State>::target_type & >() (qt_gsi::CppToQtReadAdaptor<QIcon::State>(heap, QIcon::Off), heap);
  ret.write<QList<QSize> > ((QList<QSize>)((QIconEngine_Adaptor *)cls)->cbs_availableSizes_c2846_2 (arg1, arg2));
}

static void _set_callback_cbs_availableSizes_c2846_2 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_availableSizes_c2846_2 = cb;
}


// QIconEngine *QIconEngine::clone()

static void _init_cbs_clone_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QIconEngine * > ();
}

static void _call_cbs_clone_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QIconEngine * > ((QIconEngine *)((QIconEngine_Adaptor *)cls)->cbs_clone_c0_0 ());
}

static void _set_callback_cbs_clone_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_clone_c0_0 = cb;
}


// QString QIconEngine::iconName()

static void _init_cbs_iconName_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_cbs_iconName_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QString > ((QString)((QIconEngine_Adaptor *)cls)->cbs_iconName_c0_0 ());
}

static void _set_callback_cbs_iconName_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_iconName_c0_0 = cb;
}


// QString QIconEngine::key()

static void _init_cbs_key_c0_0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QString > ();
}

static void _call_cbs_key_c0_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QString > ((QString)((QIconEngine_Adaptor *)cls)->cbs_key_c0_0 ());
}

static void _set_callback_cbs_key_c0_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_key_c0_0 = cb;
}


// void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)

static void _init_cbs_paint_5848_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("painter");
  decl->add_arg<QPainter * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("rect");
  decl->add_arg<const QRect & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_3);
  decl->set_return<void > ();
}

static void _call_cbs_paint_5848_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QPainter *arg1 = gsi::arg_reader<QPainter * >() (args, heap);
  const QRect &arg2 = gsi::arg_reader<const QRect & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg4 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine_Adaptor *)cls)->cbs_paint_5848_0 (arg1, arg2, arg3, arg4);
}

static void _set_callback_cbs_paint_5848_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_paint_5848_0 = cb;
}


// QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)

static void _init_cbs_pixmap_4543_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("size");
  decl->add_arg<const QSize & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("mode");
  decl->add_arg<const qt_gsi::Converter<QIcon::Mode>::target_type & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("state");
  decl->add_arg<const qt_gsi::Converter<QIcon::State>::target_type & > (argspec_2);
  decl->set_return<QPixmap > ();
}

static void _call_cbs_pixmap_4543_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QSize &arg1 = gsi::arg_reader<const QSize & >() (args, heap);
  const qt_gsi::Converter<QIcon::Mode>::target_type & arg2 = gsi::arg_reader<const qt_gsi::Converter<QIcon::Mode>::target_type & >() (args, heap);
  const qt_gsi::Converter<QIcon::State>::target_type & arg3 = gsi::arg_reader<const qt_gsi::Converter<QIcon::State>::target_type & >() (args, heap);
  ret.write<QPixmap > ((QPixmap)((QIconEngine_Adaptor *)cls)->cbs_pixmap_4543_0 (arg1, arg2, arg3));
}

static void _set_callback_cbs_pixmap_4543_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_pixmap_4543_0 = cb;
}


// bool QIconEngine::read(QDataStream &in)

static void _init_cbs_read_1697_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("in");
  decl->add_arg<QDataStream & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_read_1697_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QDataStream &arg1 = gsi::arg_reader<QDataStream & >() (args, heap);
  ret.write<bool > ((bool)((QIconEngine_Adaptor *)cls)->cbs_read_1697_0 (arg1));
}

static void _set_callback_cbs_read_1697_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_read_1697_0 = cb;
}


// void QIconEngine::virtual_hook(int id, void *data)

static void _init_cbs_virtual_hook_1715_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("id");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("data");
  decl->add_arg<void * > (argspec_1);
  decl->set_return<void > ();
}

static void _call_cbs_virtual_hook_1715_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  int arg1 = gsi::arg_reader<int >() (args, heap);
  void *arg2 = gsi::arg_reader<void * >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QIconEngine_Adaptor *)cls)->cbs_virtual_hook_1715_0 (arg1, arg2);
}

static void _set_callback_cbs_virtual_hook_1715_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_virtual_hook_1715_0 = cb;
}


// bool QIconEngine::write(QDataStream &out)

static void _init_cbs_write_c1697_0 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("out");
  decl->add_arg<QDataStream & > (argspec_0);
  decl->set_return<bool > ();
}

static void _call_cbs_write_c1697_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  QDataStream &arg1 = gsi::arg_reader<QDataStream & >() (args, heap);
  ret.write<bool > ((bool)((QIconEngine_Adaptor *)cls)->cbs_write_c1697_0 (arg1));
}

static void _set_callback_cbs_write_c1697_0 (void *cls, const gsi::Callback &cb)
{
  ((QIconEngine_Adaptor *)cls)->cb_write_c1697_0 = cb;
}


namespace gsi
{

gsi::Class<QIconEngine> &qtdecl_QIconEngine ();

static gsi::Methods methods_QIconEngine_Adaptor () {
  gsi::Methods methods;
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QIconEngine::QIconEngine()\nThis method creates an object of class QIconEngine.", &_init_ctor_QIconEngine_Adaptor_0, &_call_ctor_QIconEngine_Adaptor_0);
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QIconEngine::QIconEngine(const QIconEngine &other)\nThis method creates an object of class QIconEngine.", &_init_ctor_QIconEngine_Adaptor_2385, &_call_ctor_QIconEngine_Adaptor_2385);
  methods += new qt_gsi::GenericMethod ("actualSize", "@brief Virtual method QSize QIconEngine::actualSize(const QSize &size, QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_actualSize_4543_0, &_call_cbs_actualSize_4543_0);
  methods += new qt_gsi::GenericMethod ("actualSize", "@hide", false, &_init_cbs_actualSize_4543_0, &_call_cbs_actualSize_4543_0, &_set_callback_cbs_actualSize_4543_0);
  methods += new qt_gsi::GenericMethod ("addFile", "@brief Virtual method void QIconEngine::addFile(const QString &fileName, const QSize &size, QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_addFile_6460_0, &_call_cbs_addFile_6460_0);
  methods += new qt_gsi::GenericMethod ("addFile", "@hide", false, &_init_cbs_addFile_6460_0, &_call_cbs_addFile_6460_0, &_set_callback_cbs_addFile_6460_0);
  methods += new qt_gsi::GenericMethod ("addPixmap", "@brief Virtual method void QIconEngine::addPixmap(const QPixmap &pixmap, QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_addPixmap_4755_0, &_call_cbs_addPixmap_4755_0);
  methods += new qt_gsi::GenericMethod ("addPixmap", "@hide", false, &_init_cbs_addPixmap_4755_0, &_call_cbs_addPixmap_4755_0, &_set_callback_cbs_addPixmap_4755_0);
  methods += new qt_gsi::GenericMethod ("availableSizes", "@brief Virtual method QList<QSize> QIconEngine::availableSizes(QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", true, &_init_cbs_availableSizes_c2846_2, &_call_cbs_availableSizes_c2846_2);
  methods += new qt_gsi::GenericMethod ("availableSizes", "@hide", true, &_init_cbs_availableSizes_c2846_2, &_call_cbs_availableSizes_c2846_2, &_set_callback_cbs_availableSizes_c2846_2);
  methods += new qt_gsi::GenericMethod ("clone", "@brief Virtual method QIconEngine *QIconEngine::clone()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_clone_c0_0, &_call_cbs_clone_c0_0);
  methods += new qt_gsi::GenericMethod ("clone", "@hide", true, &_init_cbs_clone_c0_0, &_call_cbs_clone_c0_0, &_set_callback_cbs_clone_c0_0);
  methods += new qt_gsi::GenericMethod ("iconName", "@brief Virtual method QString QIconEngine::iconName()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_iconName_c0_0, &_call_cbs_iconName_c0_0);
  methods += new qt_gsi::GenericMethod ("iconName", "@hide", true, &_init_cbs_iconName_c0_0, &_call_cbs_iconName_c0_0, &_set_callback_cbs_iconName_c0_0);
  methods += new qt_gsi::GenericMethod ("key", "@brief Virtual method QString QIconEngine::key()\nThis method can be reimplemented in a derived class.", true, &_init_cbs_key_c0_0, &_call_cbs_key_c0_0);
  methods += new qt_gsi::GenericMethod ("key", "@hide", true, &_init_cbs_key_c0_0, &_call_cbs_key_c0_0, &_set_callback_cbs_key_c0_0);
  methods += new qt_gsi::GenericMethod ("paint", "@brief Virtual method void QIconEngine::paint(QPainter *painter, const QRect &rect, QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_paint_5848_0, &_call_cbs_paint_5848_0);
  methods += new qt_gsi::GenericMethod ("paint", "@hide", false, &_init_cbs_paint_5848_0, &_call_cbs_paint_5848_0, &_set_callback_cbs_paint_5848_0);
  methods += new qt_gsi::GenericMethod ("pixmap", "@brief Virtual method QPixmap QIconEngine::pixmap(const QSize &size, QIcon::Mode mode, QIcon::State state)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_pixmap_4543_0, &_call_cbs_pixmap_4543_0);
  methods += new qt_gsi::GenericMethod ("pixmap", "@hide", false, &_init_cbs_pixmap_4543_0, &_call_cbs_pixmap_4543_0, &_set_callback_cbs_pixmap_4543_0);
  methods += new qt_gsi::GenericMethod ("read", "@brief Virtual method bool QIconEngine::read(QDataStream &in)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_read_1697_0, &_call_cbs_read_1697_0);
  methods += new qt_gsi::GenericMethod ("read", "@hide", false, &_init_cbs_read_1697_0, &_call_cbs_read_1697_0, &_set_callback_cbs_read_1697_0);
  methods += new qt_gsi::GenericMethod ("virtual_hook", "@brief Virtual method void QIconEngine::virtual_hook(int id, void *data)\nThis method can be reimplemented in a derived class.", false, &_init_cbs_virtual_hook_1715_0, &_call_cbs_virtual_hook_1715_0);
  methods += new qt_gsi::GenericMethod ("virtual_hook", "@hide", false, &_init_cbs_virtual_hook_1715_0, &_call_cbs_virtual_hook_1715_0, &_set_callback_cbs_virtual_hook_1715_0);
  methods += new qt_gsi::GenericMethod ("write", "@brief Virtual method bool QIconEngine::write(QDataStream &out)\nThis method can be reimplemented in a derived class.", true, &_init_cbs_write_c1697_0, &_call_cbs_write_c1697_0);
  methods += new qt_gsi::GenericMethod ("write", "@hide", true, &_init_cbs_write_c1697_0, &_call_cbs_write_c1697_0, &_set_callback_cbs_write_c1697_0);
  return methods;
}

gsi::Class<QIconEngine_Adaptor> decl_QIconEngine_Adaptor (qtdecl_QIconEngine (), "QtGui", "QIconEngine",
  methods_QIconEngine_Adaptor (),
  "@qt\n@brief Binding of QIconEngine");

}

