
/*

  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 gsiDeclQMatrix4x4.cc 
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#include <QMatrix4x4>
#include <QPoint>
#include <QPointF>
#include <QQuaternion>
#include <QRect>
#include <QRectF>
#include <QTransform>
#include <QVector3D>
#include <QVector4D>
#include "gsiQt.h"
#include "gsiQtGuiCommon.h"
#include <memory>

// -----------------------------------------------------------------------
// class QMatrix4x4

//  Constructor QMatrix4x4::QMatrix4x4()


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

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


//  Constructor QMatrix4x4::QMatrix4x4(const float *values)


static void _init_ctor_QMatrix4x4_1851 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("values");
  decl->add_arg<const float * > (argspec_0);
  decl->set_return_new<QMatrix4x4> ();
}

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


//  Constructor QMatrix4x4::QMatrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)


static void _init_ctor_QMatrix4x4_13900 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("m11");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("m12");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("m13");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("m14");
  decl->add_arg<float > (argspec_3);
  static gsi::ArgSpecBase argspec_4 ("m21");
  decl->add_arg<float > (argspec_4);
  static gsi::ArgSpecBase argspec_5 ("m22");
  decl->add_arg<float > (argspec_5);
  static gsi::ArgSpecBase argspec_6 ("m23");
  decl->add_arg<float > (argspec_6);
  static gsi::ArgSpecBase argspec_7 ("m24");
  decl->add_arg<float > (argspec_7);
  static gsi::ArgSpecBase argspec_8 ("m31");
  decl->add_arg<float > (argspec_8);
  static gsi::ArgSpecBase argspec_9 ("m32");
  decl->add_arg<float > (argspec_9);
  static gsi::ArgSpecBase argspec_10 ("m33");
  decl->add_arg<float > (argspec_10);
  static gsi::ArgSpecBase argspec_11 ("m34");
  decl->add_arg<float > (argspec_11);
  static gsi::ArgSpecBase argspec_12 ("m41");
  decl->add_arg<float > (argspec_12);
  static gsi::ArgSpecBase argspec_13 ("m42");
  decl->add_arg<float > (argspec_13);
  static gsi::ArgSpecBase argspec_14 ("m43");
  decl->add_arg<float > (argspec_14);
  static gsi::ArgSpecBase argspec_15 ("m44");
  decl->add_arg<float > (argspec_15);
  decl->set_return_new<QMatrix4x4> ();
}

static void _call_ctor_QMatrix4x4_13900 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  float arg5 = gsi::arg_reader<float >() (args, heap);
  float arg6 = gsi::arg_reader<float >() (args, heap);
  float arg7 = gsi::arg_reader<float >() (args, heap);
  float arg8 = gsi::arg_reader<float >() (args, heap);
  float arg9 = gsi::arg_reader<float >() (args, heap);
  float arg10 = gsi::arg_reader<float >() (args, heap);
  float arg11 = gsi::arg_reader<float >() (args, heap);
  float arg12 = gsi::arg_reader<float >() (args, heap);
  float arg13 = gsi::arg_reader<float >() (args, heap);
  float arg14 = gsi::arg_reader<float >() (args, heap);
  float arg15 = gsi::arg_reader<float >() (args, heap);
  float arg16 = gsi::arg_reader<float >() (args, heap);
  ret.write<QMatrix4x4 *> (new QMatrix4x4 (arg1, arg2, arg3, arg4, arg5, arg6, arg7, arg8, arg9, arg10, arg11, arg12, arg13, arg14, arg15, arg16));
}


//  Constructor QMatrix4x4::QMatrix4x4(const float *values, int cols, int rows)


static void _init_ctor_QMatrix4x4_3169 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("values");
  decl->add_arg<const float * > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("cols");
  decl->add_arg<int > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("rows");
  decl->add_arg<int > (argspec_2);
  decl->set_return_new<QMatrix4x4> ();
}

static void _call_ctor_QMatrix4x4_3169 (const qt_gsi::GenericStaticMethod * /*decl*/, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const float *arg1 = gsi::arg_reader<const float * >() (args, heap);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  int arg3 = gsi::arg_reader<int >() (args, heap);
  ret.write<QMatrix4x4 *> (new QMatrix4x4 (arg1, arg2, arg3));
}


//  Constructor QMatrix4x4::QMatrix4x4(const QTransform &transform)


static void _init_ctor_QMatrix4x4_2350 (qt_gsi::GenericStaticMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("transform");
  decl->add_arg<const QTransform & > (argspec_0);
  decl->set_return_new<QMatrix4x4> ();
}

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


// QVector4D QMatrix4x4::column(int index)


static void _init_f_column_c767 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("index");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QVector4D > ();
}

static void _call_f_column_c767 (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);
  ret.write<QVector4D > ((QVector4D)((QMatrix4x4 *)cls)->column (arg1));
}


// const float *QMatrix4x4::constData()


static void _init_f_constData_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const float * > ();
}

static void _call_f_constData_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<const float * > ((const float *)((QMatrix4x4 *)cls)->constData ());
}


// void QMatrix4x4::copyDataTo(float *values)


static void _init_f_copyDataTo_c1156 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("values");
  decl->add_arg<float * > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_copyDataTo_c1156 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float *arg1 = gsi::arg_reader<float * >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->copyDataTo (arg1);
}


// float *QMatrix4x4::data()


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

static void _call_f_data_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<float * > ((float *)((QMatrix4x4 *)cls)->data ());
}


// const float *QMatrix4x4::data()


static void _init_f_data_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const float * > ();
}

static void _call_f_data_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<const float * > ((const float *)((QMatrix4x4 *)cls)->data ());
}


// double QMatrix4x4::determinant()


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

static void _call_f_determinant_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<double > ((double)((QMatrix4x4 *)cls)->determinant ());
}


// void QMatrix4x4::fill(float value)


static void _init_f_fill_970 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("value");
  decl->add_arg<float > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_fill_970 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->fill (arg1);
}


// QFlags<QMatrix4x4::Flag> QMatrix4x4::flags()


static void _init_f_flags_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<QFlags<QMatrix4x4::Flag> > ();
}

static void _call_f_flags_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QFlags<QMatrix4x4::Flag> > ((QFlags<QMatrix4x4::Flag>)((QMatrix4x4 *)cls)->flags ());
}


// void QMatrix4x4::flipCoordinates()


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

static void _call_f_flipCoordinates_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->flipCoordinates ();
}


// void QMatrix4x4::frustum(float left, float right, float bottom, float top, float nearPlane, float farPlane)


static void _init_f_frustum_5280 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("left");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("right");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("bottom");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("top");
  decl->add_arg<float > (argspec_3);
  static gsi::ArgSpecBase argspec_4 ("nearPlane");
  decl->add_arg<float > (argspec_4);
  static gsi::ArgSpecBase argspec_5 ("farPlane");
  decl->add_arg<float > (argspec_5);
  decl->set_return<void > ();
}

static void _call_f_frustum_5280 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  float arg5 = gsi::arg_reader<float >() (args, heap);
  float arg6 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->frustum (arg1, arg2, arg3, arg4, arg5, arg6);
}


// QMatrix4x4 QMatrix4x4::inverted(bool *invertible)


static void _init_f_inverted_c1050 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("invertible", true, "nullptr");
  decl->add_arg<bool * > (argspec_0);
  decl->set_return<QMatrix4x4 > ();
}

static void _call_f_inverted_c1050 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  bool *arg1 = args ? gsi::arg_reader<bool * >() (args, heap) : gsi::arg_maker<bool * >() (nullptr, heap);
  ret.write<QMatrix4x4 > ((QMatrix4x4)((QMatrix4x4 *)cls)->inverted (arg1));
}


// bool QMatrix4x4::isAffine()


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

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


// bool QMatrix4x4::isIdentity()


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

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


// void QMatrix4x4::lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up)


static void _init_f_lookAt_6204 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("eye");
  decl->add_arg<const QVector3D & > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("center");
  decl->add_arg<const QVector3D & > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("up");
  decl->add_arg<const QVector3D & > (argspec_2);
  decl->set_return<void > ();
}

static void _call_f_lookAt_6204 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QVector3D &arg1 = gsi::arg_reader<const QVector3D & >() (args, heap);
  const QVector3D &arg2 = gsi::arg_reader<const QVector3D & >() (args, heap);
  const QVector3D &arg3 = gsi::arg_reader<const QVector3D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->lookAt (arg1, arg2, arg3);
}


// QPoint QMatrix4x4::map(const QPoint &point)


static void _init_f_map_c1916 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("point");
  decl->add_arg<const QPoint & > (argspec_0);
  decl->set_return<QPoint > ();
}

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


// QPointF QMatrix4x4::map(const QPointF &point)


static void _init_f_map_c1986 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("point");
  decl->add_arg<const QPointF & > (argspec_0);
  decl->set_return<QPointF > ();
}

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


// QVector3D QMatrix4x4::map(const QVector3D &point)


static void _init_f_map_c2140 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("point");
  decl->add_arg<const QVector3D & > (argspec_0);
  decl->set_return<QVector3D > ();
}

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


// QVector4D QMatrix4x4::map(const QVector4D &point)


static void _init_f_map_c2141 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("point");
  decl->add_arg<const QVector4D & > (argspec_0);
  decl->set_return<QVector4D > ();
}

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


// QRect QMatrix4x4::mapRect(const QRect &rect)


static void _init_f_mapRect_c1792 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rect");
  decl->add_arg<const QRect & > (argspec_0);
  decl->set_return<QRect > ();
}

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


// QRectF QMatrix4x4::mapRect(const QRectF &rect)


static void _init_f_mapRect_c1862 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rect");
  decl->add_arg<const QRectF & > (argspec_0);
  decl->set_return<QRectF > ();
}

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


// QVector3D QMatrix4x4::mapVector(const QVector3D &vector)


static void _init_f_mapVector_c2140 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("vector");
  decl->add_arg<const QVector3D & > (argspec_0);
  decl->set_return<QVector3D > ();
}

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


// bool QMatrix4x4::operator!=(const QMatrix4x4 &other)


static void _init_f_operator_excl__eq__c2247 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QMatrix4x4 & > (argspec_0);
  decl->set_return<bool > ();
}

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


// const float &QMatrix4x4::operator()(int row, int column)


static void _init_f_operator_func__c1426 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("row");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("column");
  decl->add_arg<int > (argspec_1);
  decl->set_return<const float & > ();
}

static void _call_f_operator_func__c1426 (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);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  ret.write<const float & > ((const float &)((QMatrix4x4 *)cls)->operator() (arg1, arg2));
}


// float &QMatrix4x4::operator()(int row, int column)


static void _init_f_operator_func__1426 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("row");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("column");
  decl->add_arg<int > (argspec_1);
  decl->set_return<float & > ();
}

static void _call_f_operator_func__1426 (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);
  int arg2 = gsi::arg_reader<int >() (args, heap);
  ret.write<float & > ((float &)((QMatrix4x4 *)cls)->operator() (arg1, arg2));
}


// QMatrix4x4 &QMatrix4x4::operator*=(const QMatrix4x4 &other)


static void _init_f_operator_star__eq__2247 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QMatrix4x4 & > (argspec_0);
  decl->set_return<QMatrix4x4 & > ();
}

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


// QMatrix4x4 &QMatrix4x4::operator*=(float factor)


static void _init_f_operator_star__eq__970 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("factor");
  decl->add_arg<float > (argspec_0);
  decl->set_return<QMatrix4x4 & > ();
}

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


// QMatrix4x4 &QMatrix4x4::operator+=(const QMatrix4x4 &other)


static void _init_f_operator_plus__eq__2247 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QMatrix4x4 & > (argspec_0);
  decl->set_return<QMatrix4x4 & > ();
}

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


// QMatrix4x4 &QMatrix4x4::operator-=(const QMatrix4x4 &other)


static void _init_f_operator_minus__eq__2247 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QMatrix4x4 & > (argspec_0);
  decl->set_return<QMatrix4x4 & > ();
}

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


// QMatrix4x4 &QMatrix4x4::operator/=(float divisor)


static void _init_f_operator_slash__eq__970 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("divisor");
  decl->add_arg<float > (argspec_0);
  decl->set_return<QMatrix4x4 & > ();
}

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


// bool QMatrix4x4::operator==(const QMatrix4x4 &other)


static void _init_f_operator_eq__eq__c2247 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("other");
  decl->add_arg<const QMatrix4x4 & > (argspec_0);
  decl->set_return<bool > ();
}

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


// void QMatrix4x4::optimize()


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

static void _call_f_optimize_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->optimize ();
}


// void QMatrix4x4::ortho(const QRect &rect)


static void _init_f_ortho_1792 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rect");
  decl->add_arg<const QRect & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_ortho_1792 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QRect &arg1 = gsi::arg_reader<const QRect & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->ortho (arg1);
}


// void QMatrix4x4::ortho(const QRectF &rect)


static void _init_f_ortho_1862 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rect");
  decl->add_arg<const QRectF & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_ortho_1862 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QRectF &arg1 = gsi::arg_reader<const QRectF & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->ortho (arg1);
}


// void QMatrix4x4::ortho(float left, float right, float bottom, float top, float nearPlane, float farPlane)


static void _init_f_ortho_5280 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("left");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("right");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("bottom");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("top");
  decl->add_arg<float > (argspec_3);
  static gsi::ArgSpecBase argspec_4 ("nearPlane");
  decl->add_arg<float > (argspec_4);
  static gsi::ArgSpecBase argspec_5 ("farPlane");
  decl->add_arg<float > (argspec_5);
  decl->set_return<void > ();
}

static void _call_f_ortho_5280 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  float arg5 = gsi::arg_reader<float >() (args, heap);
  float arg6 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->ortho (arg1, arg2, arg3, arg4, arg5, arg6);
}


// void QMatrix4x4::perspective(float verticalAngle, float aspectRatio, float nearPlane, float farPlane)


static void _init_f_perspective_3556 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("verticalAngle");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("aspectRatio");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("nearPlane");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("farPlane");
  decl->add_arg<float > (argspec_3);
  decl->set_return<void > ();
}

static void _call_f_perspective_3556 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->perspective (arg1, arg2, arg3, arg4);
}


// void QMatrix4x4::projectedRotate(float angle, float x, float y, float z)


static void _init_f_projectedRotate_3556 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("angle");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("x");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("y");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("z");
  decl->add_arg<float > (argspec_3);
  decl->set_return<void > ();
}

static void _call_f_projectedRotate_3556 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->projectedRotate (arg1, arg2, arg3, arg4);
}


// void QMatrix4x4::rotate(float angle, const QVector3D &vector)


static void _init_f_rotate_3002 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("angle");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("vector");
  decl->add_arg<const QVector3D & > (argspec_1);
  decl->set_return<void > ();
}

static void _call_f_rotate_3002 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  const QVector3D &arg2 = gsi::arg_reader<const QVector3D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->rotate (arg1, arg2);
}


// void QMatrix4x4::rotate(float angle, float x, float y, float z)


static void _init_f_rotate_3556 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("angle");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("x");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("y");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("z", true, "0.0f");
  decl->add_arg<float > (argspec_3);
  decl->set_return<void > ();
}

static void _call_f_rotate_3556 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = args ? gsi::arg_reader<float >() (args, heap) : gsi::arg_maker<float >() (0.0f, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->rotate (arg1, arg2, arg3, arg4);
}


// void QMatrix4x4::rotate(const QQuaternion &quaternion)


static void _init_f_rotate_2456 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("quaternion");
  decl->add_arg<const QQuaternion & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_rotate_2456 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QQuaternion &arg1 = gsi::arg_reader<const QQuaternion & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->rotate (arg1);
}


// QVector4D QMatrix4x4::row(int index)


static void _init_f_row_c767 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("index");
  decl->add_arg<int > (argspec_0);
  decl->set_return<QVector4D > ();
}

static void _call_f_row_c767 (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);
  ret.write<QVector4D > ((QVector4D)((QMatrix4x4 *)cls)->row (arg1));
}


// void QMatrix4x4::scale(const QVector3D &vector)


static void _init_f_scale_2140 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("vector");
  decl->add_arg<const QVector3D & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_scale_2140 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QVector3D &arg1 = gsi::arg_reader<const QVector3D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->scale (arg1);
}


// void QMatrix4x4::scale(float x, float y)


static void _init_f_scale_1832 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("x");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("y");
  decl->add_arg<float > (argspec_1);
  decl->set_return<void > ();
}

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


// void QMatrix4x4::scale(float x, float y, float z)


static void _init_f_scale_2694 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("x");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("y");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("z");
  decl->add_arg<float > (argspec_2);
  decl->set_return<void > ();
}

static void _call_f_scale_2694 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->scale (arg1, arg2, arg3);
}


// void QMatrix4x4::scale(float factor)


static void _init_f_scale_970 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("factor");
  decl->add_arg<float > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_scale_970 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->scale (arg1);
}


// void QMatrix4x4::setColumn(int index, const QVector4D &value)


static void _init_f_setColumn_2800 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("index");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("value");
  decl->add_arg<const QVector4D & > (argspec_1);
  decl->set_return<void > ();
}

static void _call_f_setColumn_2800 (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);
  const QVector4D &arg2 = gsi::arg_reader<const QVector4D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->setColumn (arg1, arg2);
}


// void QMatrix4x4::setRow(int index, const QVector4D &value)


static void _init_f_setRow_2800 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("index");
  decl->add_arg<int > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("value");
  decl->add_arg<const QVector4D & > (argspec_1);
  decl->set_return<void > ();
}

static void _call_f_setRow_2800 (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);
  const QVector4D &arg2 = gsi::arg_reader<const QVector4D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->setRow (arg1, arg2);
}


// void QMatrix4x4::setToIdentity()


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

static void _call_f_setToIdentity_0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->setToIdentity ();
}


// QTransform QMatrix4x4::toTransform()


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

static void _call_f_toTransform_c0 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  ret.write<QTransform > ((QTransform)((QMatrix4x4 *)cls)->toTransform ());
}


// QTransform QMatrix4x4::toTransform(float distanceToPlane)


static void _init_f_toTransform_c970 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("distanceToPlane");
  decl->add_arg<float > (argspec_0);
  decl->set_return<QTransform > ();
}

static void _call_f_toTransform_c970 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  ret.write<QTransform > ((QTransform)((QMatrix4x4 *)cls)->toTransform (arg1));
}


// void QMatrix4x4::translate(const QVector3D &vector)


static void _init_f_translate_2140 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("vector");
  decl->add_arg<const QVector3D & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_translate_2140 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QVector3D &arg1 = gsi::arg_reader<const QVector3D & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->translate (arg1);
}


// void QMatrix4x4::translate(float x, float y)


static void _init_f_translate_1832 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("x");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("y");
  decl->add_arg<float > (argspec_1);
  decl->set_return<void > ();
}

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


// void QMatrix4x4::translate(float x, float y, float z)


static void _init_f_translate_2694 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("x");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("y");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("z");
  decl->add_arg<float > (argspec_2);
  decl->set_return<void > ();
}

static void _call_f_translate_2694 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->translate (arg1, arg2, arg3);
}


// QMatrix4x4 QMatrix4x4::transposed()


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

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


// void QMatrix4x4::viewport(const QRectF &rect)


static void _init_f_viewport_1862 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("rect");
  decl->add_arg<const QRectF & > (argspec_0);
  decl->set_return<void > ();
}

static void _call_f_viewport_1862 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  const QRectF &arg1 = gsi::arg_reader<const QRectF & >() (args, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->viewport (arg1);
}


// void QMatrix4x4::viewport(float left, float bottom, float width, float height, float nearPlane, float farPlane)


static void _init_f_viewport_5280 (qt_gsi::GenericMethod *decl)
{
  static gsi::ArgSpecBase argspec_0 ("left");
  decl->add_arg<float > (argspec_0);
  static gsi::ArgSpecBase argspec_1 ("bottom");
  decl->add_arg<float > (argspec_1);
  static gsi::ArgSpecBase argspec_2 ("width");
  decl->add_arg<float > (argspec_2);
  static gsi::ArgSpecBase argspec_3 ("height");
  decl->add_arg<float > (argspec_3);
  static gsi::ArgSpecBase argspec_4 ("nearPlane", true, "0.0f");
  decl->add_arg<float > (argspec_4);
  static gsi::ArgSpecBase argspec_5 ("farPlane", true, "1.0f");
  decl->add_arg<float > (argspec_5);
  decl->set_return<void > ();
}

static void _call_f_viewport_5280 (const qt_gsi::GenericMethod * /*decl*/, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  __SUPPRESS_UNUSED_WARNING(args);
  tl::Heap heap;
  float arg1 = gsi::arg_reader<float >() (args, heap);
  float arg2 = gsi::arg_reader<float >() (args, heap);
  float arg3 = gsi::arg_reader<float >() (args, heap);
  float arg4 = gsi::arg_reader<float >() (args, heap);
  float arg5 = args ? gsi::arg_reader<float >() (args, heap) : gsi::arg_maker<float >() (0.0f, heap);
  float arg6 = args ? gsi::arg_reader<float >() (args, heap) : gsi::arg_maker<float >() (1.0f, heap);
  __SUPPRESS_UNUSED_WARNING(ret);
  ((QMatrix4x4 *)cls)->viewport (arg1, arg2, arg3, arg4, arg5, arg6);
}


//  QMatrix4x4 ::operator/(const QMatrix4x4 &matrix, float divisor)
static QMatrix4x4 op_QMatrix4x4_operator_slash__3109(const QMatrix4x4 *_self, float divisor) {
  return operator/(*_self, divisor);
}

//  QMatrix4x4 ::operator+(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_plus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
  return operator+(*_self, m2);
}

//  QMatrix4x4 ::operator-(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_minus__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
  return operator-(*_self, m2);
}

//  QMatrix4x4 ::operator*(const QMatrix4x4 &m1, const QMatrix4x4 &m2)
static QMatrix4x4 op_QMatrix4x4_operator_star__4386(const QMatrix4x4 *_self, const QMatrix4x4 &m2) {
  return operator*(*_self, m2);
}

//  QVector3D ::operator*(const QMatrix4x4 &matrix, const QVector3D &vector)
static QVector3D op_QMatrix4x4_operator_star__4279(const QMatrix4x4 *_self, const QVector3D &vector) {
  return operator*(*_self, vector);
}

//  QVector4D ::operator*(const QMatrix4x4 &matrix, const QVector4D &vector)
static QVector4D op_QMatrix4x4_operator_star__4280(const QMatrix4x4 *_self, const QVector4D &vector) {
  return operator*(*_self, vector);
}

//  QPoint ::operator*(const QMatrix4x4 &matrix, const QPoint &point)
static QPoint op_QMatrix4x4_operator_star__4055(const QMatrix4x4 *_self, const QPoint &point) {
  return operator*(*_self, point);
}

//  QPointF ::operator*(const QMatrix4x4 &matrix, const QPointF &point)
static QPointF op_QMatrix4x4_operator_star__4125(const QMatrix4x4 *_self, const QPointF &point) {
  return operator*(*_self, point);
}

//  QMatrix4x4 ::operator-(const QMatrix4x4 &matrix)
static QMatrix4x4 op_QMatrix4x4_operator_minus__2247(const QMatrix4x4 *_self) {
  return operator-(*_self);
}

//  QMatrix4x4 ::operator*(const QMatrix4x4 &matrix, float factor)
static QMatrix4x4 op_QMatrix4x4_operator_star__3109(const QMatrix4x4 *_self, float factor) {
  return operator*(*_self, factor);
}


namespace gsi
{

static gsi::Methods methods_QMatrix4x4 () {
  gsi::Methods methods;
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMatrix4x4::QMatrix4x4()\nThis method creates an object of class QMatrix4x4.", &_init_ctor_QMatrix4x4_0, &_call_ctor_QMatrix4x4_0);
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMatrix4x4::QMatrix4x4(const float *values)\nThis method creates an object of class QMatrix4x4.", &_init_ctor_QMatrix4x4_1851, &_call_ctor_QMatrix4x4_1851);
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMatrix4x4::QMatrix4x4(float m11, float m12, float m13, float m14, float m21, float m22, float m23, float m24, float m31, float m32, float m33, float m34, float m41, float m42, float m43, float m44)\nThis method creates an object of class QMatrix4x4.", &_init_ctor_QMatrix4x4_13900, &_call_ctor_QMatrix4x4_13900);
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMatrix4x4::QMatrix4x4(const float *values, int cols, int rows)\nThis method creates an object of class QMatrix4x4.", &_init_ctor_QMatrix4x4_3169, &_call_ctor_QMatrix4x4_3169);
  methods += new qt_gsi::GenericStaticMethod ("new", "@brief Constructor QMatrix4x4::QMatrix4x4(const QTransform &transform)\nThis method creates an object of class QMatrix4x4.", &_init_ctor_QMatrix4x4_2350, &_call_ctor_QMatrix4x4_2350);
  methods += new qt_gsi::GenericMethod ("column", "@brief Method QVector4D QMatrix4x4::column(int index)\n", true, &_init_f_column_c767, &_call_f_column_c767);
  methods += new qt_gsi::GenericMethod ("constData", "@brief Method const float *QMatrix4x4::constData()\n", true, &_init_f_constData_c0, &_call_f_constData_c0);
  methods += new qt_gsi::GenericMethod ("copyDataTo", "@brief Method void QMatrix4x4::copyDataTo(float *values)\n", true, &_init_f_copyDataTo_c1156, &_call_f_copyDataTo_c1156);
  methods += new qt_gsi::GenericMethod ("data", "@brief Method float *QMatrix4x4::data()\n", false, &_init_f_data_0, &_call_f_data_0);
  methods += new qt_gsi::GenericMethod ("data", "@brief Method const float *QMatrix4x4::data()\n", true, &_init_f_data_c0, &_call_f_data_c0);
  methods += new qt_gsi::GenericMethod ("determinant", "@brief Method double QMatrix4x4::determinant()\n", true, &_init_f_determinant_c0, &_call_f_determinant_c0);
  methods += new qt_gsi::GenericMethod ("fill", "@brief Method void QMatrix4x4::fill(float value)\n", false, &_init_f_fill_970, &_call_f_fill_970);
  methods += new qt_gsi::GenericMethod ("flags", "@brief Method QFlags<QMatrix4x4::Flag> QMatrix4x4::flags()\n", true, &_init_f_flags_c0, &_call_f_flags_c0);
  methods += new qt_gsi::GenericMethod ("flipCoordinates", "@brief Method void QMatrix4x4::flipCoordinates()\n", false, &_init_f_flipCoordinates_0, &_call_f_flipCoordinates_0);
  methods += new qt_gsi::GenericMethod ("frustum", "@brief Method void QMatrix4x4::frustum(float left, float right, float bottom, float top, float nearPlane, float farPlane)\n", false, &_init_f_frustum_5280, &_call_f_frustum_5280);
  methods += new qt_gsi::GenericMethod ("inverted", "@brief Method QMatrix4x4 QMatrix4x4::inverted(bool *invertible)\n", true, &_init_f_inverted_c1050, &_call_f_inverted_c1050);
  methods += new qt_gsi::GenericMethod ("isAffine?", "@brief Method bool QMatrix4x4::isAffine()\n", true, &_init_f_isAffine_c0, &_call_f_isAffine_c0);
  methods += new qt_gsi::GenericMethod ("isIdentity?", "@brief Method bool QMatrix4x4::isIdentity()\n", true, &_init_f_isIdentity_c0, &_call_f_isIdentity_c0);
  methods += new qt_gsi::GenericMethod ("lookAt", "@brief Method void QMatrix4x4::lookAt(const QVector3D &eye, const QVector3D &center, const QVector3D &up)\n", false, &_init_f_lookAt_6204, &_call_f_lookAt_6204);
  methods += new qt_gsi::GenericMethod ("map", "@brief Method QPoint QMatrix4x4::map(const QPoint &point)\n", true, &_init_f_map_c1916, &_call_f_map_c1916);
  methods += new qt_gsi::GenericMethod ("map", "@brief Method QPointF QMatrix4x4::map(const QPointF &point)\n", true, &_init_f_map_c1986, &_call_f_map_c1986);
  methods += new qt_gsi::GenericMethod ("map", "@brief Method QVector3D QMatrix4x4::map(const QVector3D &point)\n", true, &_init_f_map_c2140, &_call_f_map_c2140);
  methods += new qt_gsi::GenericMethod ("map", "@brief Method QVector4D QMatrix4x4::map(const QVector4D &point)\n", true, &_init_f_map_c2141, &_call_f_map_c2141);
  methods += new qt_gsi::GenericMethod ("mapRect", "@brief Method QRect QMatrix4x4::mapRect(const QRect &rect)\n", true, &_init_f_mapRect_c1792, &_call_f_mapRect_c1792);
  methods += new qt_gsi::GenericMethod ("mapRect", "@brief Method QRectF QMatrix4x4::mapRect(const QRectF &rect)\n", true, &_init_f_mapRect_c1862, &_call_f_mapRect_c1862);
  methods += new qt_gsi::GenericMethod ("mapVector", "@brief Method QVector3D QMatrix4x4::mapVector(const QVector3D &vector)\n", true, &_init_f_mapVector_c2140, &_call_f_mapVector_c2140);
  methods += new qt_gsi::GenericMethod ("!=", "@brief Method bool QMatrix4x4::operator!=(const QMatrix4x4 &other)\n", true, &_init_f_operator_excl__eq__c2247, &_call_f_operator_excl__eq__c2247);
  methods += new qt_gsi::GenericMethod ("()", "@brief Method const float &QMatrix4x4::operator()(int row, int column)\n", true, &_init_f_operator_func__c1426, &_call_f_operator_func__c1426);
  methods += new qt_gsi::GenericMethod ("()", "@brief Method float &QMatrix4x4::operator()(int row, int column)\n", false, &_init_f_operator_func__1426, &_call_f_operator_func__1426);
  methods += new qt_gsi::GenericMethod ("*=", "@brief Method QMatrix4x4 &QMatrix4x4::operator*=(const QMatrix4x4 &other)\n", false, &_init_f_operator_star__eq__2247, &_call_f_operator_star__eq__2247);
  methods += new qt_gsi::GenericMethod ("*=", "@brief Method QMatrix4x4 &QMatrix4x4::operator*=(float factor)\n", false, &_init_f_operator_star__eq__970, &_call_f_operator_star__eq__970);
  methods += new qt_gsi::GenericMethod ("+=", "@brief Method QMatrix4x4 &QMatrix4x4::operator+=(const QMatrix4x4 &other)\n", false, &_init_f_operator_plus__eq__2247, &_call_f_operator_plus__eq__2247);
  methods += new qt_gsi::GenericMethod ("-=", "@brief Method QMatrix4x4 &QMatrix4x4::operator-=(const QMatrix4x4 &other)\n", false, &_init_f_operator_minus__eq__2247, &_call_f_operator_minus__eq__2247);
  methods += new qt_gsi::GenericMethod ("/=", "@brief Method QMatrix4x4 &QMatrix4x4::operator/=(float divisor)\n", false, &_init_f_operator_slash__eq__970, &_call_f_operator_slash__eq__970);
  methods += new qt_gsi::GenericMethod ("==", "@brief Method bool QMatrix4x4::operator==(const QMatrix4x4 &other)\n", true, &_init_f_operator_eq__eq__c2247, &_call_f_operator_eq__eq__c2247);
  methods += new qt_gsi::GenericMethod ("optimize", "@brief Method void QMatrix4x4::optimize()\n", false, &_init_f_optimize_0, &_call_f_optimize_0);
  methods += new qt_gsi::GenericMethod ("ortho", "@brief Method void QMatrix4x4::ortho(const QRect &rect)\n", false, &_init_f_ortho_1792, &_call_f_ortho_1792);
  methods += new qt_gsi::GenericMethod ("ortho", "@brief Method void QMatrix4x4::ortho(const QRectF &rect)\n", false, &_init_f_ortho_1862, &_call_f_ortho_1862);
  methods += new qt_gsi::GenericMethod ("ortho", "@brief Method void QMatrix4x4::ortho(float left, float right, float bottom, float top, float nearPlane, float farPlane)\n", false, &_init_f_ortho_5280, &_call_f_ortho_5280);
  methods += new qt_gsi::GenericMethod ("perspective", "@brief Method void QMatrix4x4::perspective(float verticalAngle, float aspectRatio, float nearPlane, float farPlane)\n", false, &_init_f_perspective_3556, &_call_f_perspective_3556);
  methods += new qt_gsi::GenericMethod ("projectedRotate", "@brief Method void QMatrix4x4::projectedRotate(float angle, float x, float y, float z)\n", false, &_init_f_projectedRotate_3556, &_call_f_projectedRotate_3556);
  methods += new qt_gsi::GenericMethod ("rotate", "@brief Method void QMatrix4x4::rotate(float angle, const QVector3D &vector)\n", false, &_init_f_rotate_3002, &_call_f_rotate_3002);
  methods += new qt_gsi::GenericMethod ("rotate", "@brief Method void QMatrix4x4::rotate(float angle, float x, float y, float z)\n", false, &_init_f_rotate_3556, &_call_f_rotate_3556);
  methods += new qt_gsi::GenericMethod ("rotate", "@brief Method void QMatrix4x4::rotate(const QQuaternion &quaternion)\n", false, &_init_f_rotate_2456, &_call_f_rotate_2456);
  methods += new qt_gsi::GenericMethod ("row", "@brief Method QVector4D QMatrix4x4::row(int index)\n", true, &_init_f_row_c767, &_call_f_row_c767);
  methods += new qt_gsi::GenericMethod ("scale", "@brief Method void QMatrix4x4::scale(const QVector3D &vector)\n", false, &_init_f_scale_2140, &_call_f_scale_2140);
  methods += new qt_gsi::GenericMethod ("scale", "@brief Method void QMatrix4x4::scale(float x, float y)\n", false, &_init_f_scale_1832, &_call_f_scale_1832);
  methods += new qt_gsi::GenericMethod ("scale", "@brief Method void QMatrix4x4::scale(float x, float y, float z)\n", false, &_init_f_scale_2694, &_call_f_scale_2694);
  methods += new qt_gsi::GenericMethod ("scale", "@brief Method void QMatrix4x4::scale(float factor)\n", false, &_init_f_scale_970, &_call_f_scale_970);
  methods += new qt_gsi::GenericMethod ("setColumn", "@brief Method void QMatrix4x4::setColumn(int index, const QVector4D &value)\n", false, &_init_f_setColumn_2800, &_call_f_setColumn_2800);
  methods += new qt_gsi::GenericMethod ("setRow", "@brief Method void QMatrix4x4::setRow(int index, const QVector4D &value)\n", false, &_init_f_setRow_2800, &_call_f_setRow_2800);
  methods += new qt_gsi::GenericMethod ("setToIdentity", "@brief Method void QMatrix4x4::setToIdentity()\n", false, &_init_f_setToIdentity_0, &_call_f_setToIdentity_0);
  methods += new qt_gsi::GenericMethod ("toTransform", "@brief Method QTransform QMatrix4x4::toTransform()\n", true, &_init_f_toTransform_c0, &_call_f_toTransform_c0);
  methods += new qt_gsi::GenericMethod ("toTransform", "@brief Method QTransform QMatrix4x4::toTransform(float distanceToPlane)\n", true, &_init_f_toTransform_c970, &_call_f_toTransform_c970);
  methods += new qt_gsi::GenericMethod ("translate", "@brief Method void QMatrix4x4::translate(const QVector3D &vector)\n", false, &_init_f_translate_2140, &_call_f_translate_2140);
  methods += new qt_gsi::GenericMethod ("translate", "@brief Method void QMatrix4x4::translate(float x, float y)\n", false, &_init_f_translate_1832, &_call_f_translate_1832);
  methods += new qt_gsi::GenericMethod ("translate", "@brief Method void QMatrix4x4::translate(float x, float y, float z)\n", false, &_init_f_translate_2694, &_call_f_translate_2694);
  methods += new qt_gsi::GenericMethod ("transposed", "@brief Method QMatrix4x4 QMatrix4x4::transposed()\n", true, &_init_f_transposed_c0, &_call_f_transposed_c0);
  methods += new qt_gsi::GenericMethod ("viewport", "@brief Method void QMatrix4x4::viewport(const QRectF &rect)\n", false, &_init_f_viewport_1862, &_call_f_viewport_1862);
  methods += new qt_gsi::GenericMethod ("viewport", "@brief Method void QMatrix4x4::viewport(float left, float bottom, float width, float height, float nearPlane, float farPlane)\n", false, &_init_f_viewport_5280, &_call_f_viewport_5280);
  methods += gsi::method_ext("/", &::op_QMatrix4x4_operator_slash__3109, gsi::arg ("divisor"), "@brief Operator QMatrix4x4 ::operator/(const QMatrix4x4 &matrix, float divisor)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("+", &::op_QMatrix4x4_operator_plus__4386, gsi::arg ("m2"), "@brief Operator QMatrix4x4 ::operator+(const QMatrix4x4 &m1, const QMatrix4x4 &m2)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("-", &::op_QMatrix4x4_operator_minus__4386, gsi::arg ("m2"), "@brief Operator QMatrix4x4 ::operator-(const QMatrix4x4 &m1, const QMatrix4x4 &m2)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__4386, gsi::arg ("m2"), "@brief Operator QMatrix4x4 ::operator*(const QMatrix4x4 &m1, const QMatrix4x4 &m2)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__4279, gsi::arg ("vector"), "@brief Operator QVector3D ::operator*(const QMatrix4x4 &matrix, const QVector3D &vector)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__4280, gsi::arg ("vector"), "@brief Operator QVector4D ::operator*(const QMatrix4x4 &matrix, const QVector4D &vector)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__4055, gsi::arg ("point"), "@brief Operator QPoint ::operator*(const QMatrix4x4 &matrix, const QPoint &point)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__4125, gsi::arg ("point"), "@brief Operator QPointF ::operator*(const QMatrix4x4 &matrix, const QPointF &point)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("-", &::op_QMatrix4x4_operator_minus__2247, "@brief Operator QMatrix4x4 ::operator-(const QMatrix4x4 &matrix)\nThis is the mapping of the global operator to the instance method.");
  methods += gsi::method_ext("*", &::op_QMatrix4x4_operator_star__3109, gsi::arg ("factor"), "@brief Operator QMatrix4x4 ::operator*(const QMatrix4x4 &matrix, float factor)\nThis is the mapping of the global operator to the instance method.");
  return methods;
}

gsi::Class<QMatrix4x4> decl_QMatrix4x4 ("QtGui", "QMatrix4x4",
  methods_QMatrix4x4 (),
  "@qt\n@brief Binding of QMatrix4x4");


GSI_QTGUI_PUBLIC gsi::Class<QMatrix4x4> &qtdecl_QMatrix4x4 () { return decl_QMatrix4x4; }

}


//  Implementation of the enum wrapper class for QMatrix4x4::Flag
namespace qt_gsi
{

static gsi::Enum<QMatrix4x4::Flag> decl_QMatrix4x4_Flag_Enum ("QtGui", "QMatrix4x4_Flag",
    gsi::enum_const ("Identity", QMatrix4x4::Identity, "@brief Enum constant QMatrix4x4::Identity") +
    gsi::enum_const ("Translation", QMatrix4x4::Translation, "@brief Enum constant QMatrix4x4::Translation") +
    gsi::enum_const ("Scale", QMatrix4x4::Scale, "@brief Enum constant QMatrix4x4::Scale") +
    gsi::enum_const ("Rotation2D", QMatrix4x4::Rotation2D, "@brief Enum constant QMatrix4x4::Rotation2D") +
    gsi::enum_const ("Rotation", QMatrix4x4::Rotation, "@brief Enum constant QMatrix4x4::Rotation") +
    gsi::enum_const ("Perspective", QMatrix4x4::Perspective, "@brief Enum constant QMatrix4x4::Perspective") +
    gsi::enum_const ("General", QMatrix4x4::General, "@brief Enum constant QMatrix4x4::General"),
  "@qt\n@brief This class represents the QMatrix4x4::Flag enum");

static gsi::QFlagsClass<QMatrix4x4::Flag > decl_QMatrix4x4_Flag_Enums ("QtGui", "QMatrix4x4_QFlags_Flag",
  "@qt\n@brief This class represents the QFlags<QMatrix4x4::Flag> flag set");

//  Inject the declarations into the parent
static gsi::ClassExt<QMatrix4x4> inject_QMatrix4x4_Flag_Enum_in_parent (decl_QMatrix4x4_Flag_Enum.defs ());
static gsi::ClassExt<QMatrix4x4> decl_QMatrix4x4_Flag_Enum_as_child (decl_QMatrix4x4_Flag_Enum, "Flag");
static gsi::ClassExt<QMatrix4x4> decl_QMatrix4x4_Flag_Enums_as_child (decl_QMatrix4x4_Flag_Enums, "QFlags_Flag");

}

