
/*

  KLayout Layout Viewer
  Copyright (C) 2006-2016 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 gsiDeclQTabletEvent.cc 
*
*  DO NOT EDIT THIS FILE. 
*  This file has been created automatically
*/

#include "gsiQtGui.h"
#include "gsiDeclQtTypeTraits.h"
#include "gsiDeclQTabletEvent_Enums.h"
#include <memory>

// -----------------------------------------------------------------------
// class QTabletEvent

// QTabletEvent::TabletDevice QTabletEvent::device()


static void _init_f_device_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<qt_gsi::Converter<QTabletEvent::TabletDevice>::target_type > ();
}

static void _call_f_device_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<qt_gsi::Converter<QTabletEvent::TabletDevice>::target_type > ((qt_gsi::Converter<QTabletEvent::TabletDevice>::target_type)qt_gsi::CppToQtAdaptor<QTabletEvent::TabletDevice>(((QTabletEvent *)cls)->device ()));
}

static qt_gsi::GenericMethod *_create_f_device_c0 ()
{
  return new qt_gsi::GenericMethod ("device", "@brief Method QTabletEvent::TabletDevice QTabletEvent::device()\n", true, &_init_f_device_c0, &_call_f_device_c0);
}

// const QPoint &QTabletEvent::globalPos()


static void _init_f_globalPos_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const QPoint & > ();
}

static void _call_f_globalPos_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<const QPoint & > ((const QPoint &)((QTabletEvent *)cls)->globalPos ());
}

static qt_gsi::GenericMethod *_create_f_globalPos_c0 ()
{
  return new qt_gsi::GenericMethod ("globalPos", "@brief Method const QPoint &QTabletEvent::globalPos()\n", true, &_init_f_globalPos_c0, &_call_f_globalPos_c0);
}

// int QTabletEvent::globalX()


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

static void _call_f_globalX_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->globalX ());
}

static qt_gsi::GenericMethod *_create_f_globalX_c0 ()
{
  return new qt_gsi::GenericMethod ("globalX", "@brief Method int QTabletEvent::globalX()\n", true, &_init_f_globalX_c0, &_call_f_globalX_c0);
}

// int QTabletEvent::globalY()


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

static void _call_f_globalY_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->globalY ());
}

static qt_gsi::GenericMethod *_create_f_globalY_c0 ()
{
  return new qt_gsi::GenericMethod ("globalY", "@brief Method int QTabletEvent::globalY()\n", true, &_init_f_globalY_c0, &_call_f_globalY_c0);
}

// const QPointF &QTabletEvent::hiResGlobalPos()


static void _init_f_hiResGlobalPos_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const QPointF & > ();
}

static void _call_f_hiResGlobalPos_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<const QPointF & > ((const QPointF &)((QTabletEvent *)cls)->hiResGlobalPos ());
}

static qt_gsi::GenericMethod *_create_f_hiResGlobalPos_c0 ()
{
  return new qt_gsi::GenericMethod ("hiResGlobalPos", "@brief Method const QPointF &QTabletEvent::hiResGlobalPos()\n", true, &_init_f_hiResGlobalPos_c0, &_call_f_hiResGlobalPos_c0);
}

// double QTabletEvent::hiResGlobalX()


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

static void _call_f_hiResGlobalX_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<double > ((double)((QTabletEvent *)cls)->hiResGlobalX ());
}

static qt_gsi::GenericMethod *_create_f_hiResGlobalX_c0 ()
{
  return new qt_gsi::GenericMethod ("hiResGlobalX", "@brief Method double QTabletEvent::hiResGlobalX()\n", true, &_init_f_hiResGlobalX_c0, &_call_f_hiResGlobalX_c0);
}

// double QTabletEvent::hiResGlobalY()


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

static void _call_f_hiResGlobalY_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<double > ((double)((QTabletEvent *)cls)->hiResGlobalY ());
}

static qt_gsi::GenericMethod *_create_f_hiResGlobalY_c0 ()
{
  return new qt_gsi::GenericMethod ("hiResGlobalY", "@brief Method double QTabletEvent::hiResGlobalY()\n", true, &_init_f_hiResGlobalY_c0, &_call_f_hiResGlobalY_c0);
}

// QTabletEvent::PointerType QTabletEvent::pointerType()


static void _init_f_pointerType_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<qt_gsi::Converter<QTabletEvent::PointerType>::target_type > ();
}

static void _call_f_pointerType_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<qt_gsi::Converter<QTabletEvent::PointerType>::target_type > ((qt_gsi::Converter<QTabletEvent::PointerType>::target_type)qt_gsi::CppToQtAdaptor<QTabletEvent::PointerType>(((QTabletEvent *)cls)->pointerType ()));
}

static qt_gsi::GenericMethod *_create_f_pointerType_c0 ()
{
  return new qt_gsi::GenericMethod ("pointerType", "@brief Method QTabletEvent::PointerType QTabletEvent::pointerType()\n", true, &_init_f_pointerType_c0, &_call_f_pointerType_c0);
}

// const QPoint &QTabletEvent::pos()


static void _init_f_pos_c0 (qt_gsi::GenericMethod *decl)
{
  decl->set_return<const QPoint & > ();
}

static void _call_f_pos_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<const QPoint & > ((const QPoint &)((QTabletEvent *)cls)->pos ());
}

static qt_gsi::GenericMethod *_create_f_pos_c0 ()
{
  return new qt_gsi::GenericMethod ("pos", "@brief Method const QPoint &QTabletEvent::pos()\n", true, &_init_f_pos_c0, &_call_f_pos_c0);
}

// double QTabletEvent::pressure()


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

static void _call_f_pressure_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<double > ((double)((QTabletEvent *)cls)->pressure ());
}

static qt_gsi::GenericMethod *_create_f_pressure_c0 ()
{
  return new qt_gsi::GenericMethod ("pressure", "@brief Method double QTabletEvent::pressure()\n", true, &_init_f_pressure_c0, &_call_f_pressure_c0);
}

// double QTabletEvent::rotation()


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

static void _call_f_rotation_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<double > ((double)((QTabletEvent *)cls)->rotation ());
}

static qt_gsi::GenericMethod *_create_f_rotation_c0 ()
{
  return new qt_gsi::GenericMethod ("rotation", "@brief Method double QTabletEvent::rotation()\n", true, &_init_f_rotation_c0, &_call_f_rotation_c0);
}

// double QTabletEvent::tangentialPressure()


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

static void _call_f_tangentialPressure_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<double > ((double)((QTabletEvent *)cls)->tangentialPressure ());
}

static qt_gsi::GenericMethod *_create_f_tangentialPressure_c0 ()
{
  return new qt_gsi::GenericMethod ("tangentialPressure", "@brief Method double QTabletEvent::tangentialPressure()\n", true, &_init_f_tangentialPressure_c0, &_call_f_tangentialPressure_c0);
}

// qint64 QTabletEvent::uniqueId()


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

static void _call_f_uniqueId_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<qint64 > ((qint64)((QTabletEvent *)cls)->uniqueId ());
}

static qt_gsi::GenericMethod *_create_f_uniqueId_c0 ()
{
  return new qt_gsi::GenericMethod ("uniqueId", "@brief Method qint64 QTabletEvent::uniqueId()\n", true, &_init_f_uniqueId_c0, &_call_f_uniqueId_c0);
}

// int QTabletEvent::x()


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

static void _call_f_x_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->x ());
}

static qt_gsi::GenericMethod *_create_f_x_c0 ()
{
  return new qt_gsi::GenericMethod ("x", "@brief Method int QTabletEvent::x()\n", true, &_init_f_x_c0, &_call_f_x_c0);
}

// int QTabletEvent::xTilt()


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

static void _call_f_xTilt_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->xTilt ());
}

static qt_gsi::GenericMethod *_create_f_xTilt_c0 ()
{
  return new qt_gsi::GenericMethod ("xTilt", "@brief Method int QTabletEvent::xTilt()\n", true, &_init_f_xTilt_c0, &_call_f_xTilt_c0);
}

// int QTabletEvent::y()


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

static void _call_f_y_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->y ());
}

static qt_gsi::GenericMethod *_create_f_y_c0 ()
{
  return new qt_gsi::GenericMethod ("y", "@brief Method int QTabletEvent::y()\n", true, &_init_f_y_c0, &_call_f_y_c0);
}

// int QTabletEvent::yTilt()


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

static void _call_f_yTilt_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->yTilt ());
}

static qt_gsi::GenericMethod *_create_f_yTilt_c0 ()
{
  return new qt_gsi::GenericMethod ("yTilt", "@brief Method int QTabletEvent::yTilt()\n", true, &_init_f_yTilt_c0, &_call_f_yTilt_c0);
}

// int QTabletEvent::z()


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

static void _call_f_z_c0 (const qt_gsi::GenericMethod *decl, void *cls, gsi::SerialArgs &args, gsi::SerialArgs &ret) 
{
  ret.write<int > ((int)((QTabletEvent *)cls)->z ());
}

static qt_gsi::GenericMethod *_create_f_z_c0 ()
{
  return new qt_gsi::GenericMethod ("z", "@brief Method int QTabletEvent::z()\n", true, &_init_f_z_c0, &_call_f_z_c0);
}

namespace gsi
{
extern gsi::Class<QInputEvent> decl_QInputEvent;

gsi::Class<QTabletEvent> decl_QTabletEvent (decl_QInputEvent, "QTabletEvent_Native",
  gsi::Methods(_create_f_device_c0 ()) +
  gsi::Methods(_create_f_globalPos_c0 ()) +
  gsi::Methods(_create_f_globalX_c0 ()) +
  gsi::Methods(_create_f_globalY_c0 ()) +
  gsi::Methods(_create_f_hiResGlobalPos_c0 ()) +
  gsi::Methods(_create_f_hiResGlobalX_c0 ()) +
  gsi::Methods(_create_f_hiResGlobalY_c0 ()) +
  gsi::Methods(_create_f_pointerType_c0 ()) +
  gsi::Methods(_create_f_pos_c0 ()) +
  gsi::Methods(_create_f_pressure_c0 ()) +
  gsi::Methods(_create_f_rotation_c0 ()) +
  gsi::Methods(_create_f_tangentialPressure_c0 ()) +
  gsi::Methods(_create_f_uniqueId_c0 ()) +
  gsi::Methods(_create_f_x_c0 ()) +
  gsi::Methods(_create_f_xTilt_c0 ()) +
  gsi::Methods(_create_f_y_c0 ()) +
  gsi::Methods(_create_f_yTilt_c0 ()) +
  gsi::Methods(_create_f_z_c0 ()),
  "@hide\n@alias QTabletEvent");
}


class QTabletEvent_Adaptor : public QTabletEvent, public qt_gsi::QtObjectBase
{
public:

  virtual ~QTabletEvent_Adaptor();

  
};

QTabletEvent_Adaptor::~QTabletEvent_Adaptor() { }

namespace gsi
{

extern gsi::Class<QTabletEvent> decl_QTabletEvent;

gsi::Class<QTabletEvent_Adaptor> decl_QTabletEvent_Adaptor (decl_QTabletEvent, "QTabletEvent",
  gsi::Methods(),
  "@qt\n@brief Binding of QTabletEvent");

}


//  Implementation of the enum wrapper class for QTabletEvent::PointerType
namespace qt_gsi
{

static QTabletEvent_PointerType_Enum *c_1_QTabletEvent_PointerType_Enum () { return new QTabletEvent_PointerType_Enum (QTabletEvent::UnknownPointer); }
static QTabletEvent_PointerType_Enum *c_2_QTabletEvent_PointerType_Enum () { return new QTabletEvent_PointerType_Enum (QTabletEvent::Pen); }
static QTabletEvent_PointerType_Enum *c_3_QTabletEvent_PointerType_Enum () { return new QTabletEvent_PointerType_Enum (QTabletEvent::Cursor); }
static QTabletEvent_PointerType_Enum *c_4_QTabletEvent_PointerType_Enum () { return new QTabletEvent_PointerType_Enum (QTabletEvent::Eraser); }

static gsi::Methods mkdefs_QTabletEvent_PointerType () {
  return
    gsi::constant ("UnknownPointer", &qt_gsi::c_1_QTabletEvent_PointerType_Enum, "@brief Enum constant QTabletEvent::UnknownPointer") +
    gsi::constant ("Pen", &qt_gsi::c_2_QTabletEvent_PointerType_Enum, "@brief Enum constant QTabletEvent::Pen") +
    gsi::constant ("Cursor", &qt_gsi::c_3_QTabletEvent_PointerType_Enum, "@brief Enum constant QTabletEvent::Cursor") +
    gsi::constant ("Eraser", &qt_gsi::c_4_QTabletEvent_PointerType_Enum, "@brief Enum constant QTabletEvent::Eraser");
}

static std::string to_s_QTabletEvent_PointerType_Enum (const QTabletEvent_PointerType_Enum *e)
{
  if (e->value () == QTabletEvent::UnknownPointer) { return tl::sprintf ("UnknownPointer (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Pen) { return tl::sprintf ("Pen (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Cursor) { return tl::sprintf ("Cursor (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Eraser) { return tl::sprintf ("Eraser (%u)", (unsigned int) e->value ()); }
  return std::string ("(not a valid enum evalue)");
}

static unsigned int to_i_QTabletEvent_PointerType_Enum (const QTabletEvent_PointerType_Enum *e)
{
  return (unsigned int) e->value ();
}

static QTabletEvent_PointerType_Enum *from_i_QTabletEvent_PointerType_Enum (unsigned int i)
{
  return new QTabletEvent_PointerType_Enum ((QTabletEvent::PointerType) i);
}

static bool equalQTabletEvent_PointerType_Enum (const QTabletEvent_PointerType_Enum *e, QTabletEvent_PointerType_Enum d)
{
  return e->value () == d.value ();
}

static bool equal2QTabletEvent_PointerType_Enum (const QTabletEvent_PointerType_Enum *e, unsigned int i)
{
  return (unsigned int) e->value () == i;
}

static QTabletEvent_PointerType_Enums oropQTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e, const QTabletEvent_PointerType_Enums &d)
{
  return e->flags () | d.flags ();
}

static QTabletEvent_PointerType_Enums andopQTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e, const QTabletEvent_PointerType_Enums &d)
{
  return e->flags () & d.flags ();
}

static QTabletEvent_PointerType_Enums xoropQTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e, const QTabletEvent_PointerType_Enums &d)
{
  return e->flags () ^ d.flags ();
}

static std::string to_s_QTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e)
{
  std::string l;
  if (e->testFlag (QTabletEvent::UnknownPointer)) { if (!l.empty ()) l += "|"; l += "UnknownPointer"; }
  if (e->testFlag (QTabletEvent::Pen)) { if (!l.empty ()) l += "|"; l += "Pen"; }
  if (e->testFlag (QTabletEvent::Cursor)) { if (!l.empty ()) l += "|"; l += "Cursor"; }
  if (e->testFlag (QTabletEvent::Eraser)) { if (!l.empty ()) l += "|"; l += "Eraser"; }
  return tl::sprintf ("%u (%s)", (unsigned int) (e->flags ()), l);
}

static int to_i_QTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e)
{
  return int (e->flags ());
}

static bool testFlag_QTabletEvent_PointerType_Enums (const QTabletEvent_PointerType_Enums *e, const QTabletEvent_PointerType_Enum &d)
{
  return e->flags ().testFlag (d.value ());
}

}

namespace gsi
{

//  Declarations for QFlags<enum> wrapper class
gsi::Class<qt_gsi::QTabletEvent_PointerType_Enums> decl_QTabletEvent_PointerType_Enums ("QTabletEvent_QFlags_PointerType",
  gsi::method_ext ("|", &qt_gsi::oropQTabletEvent_PointerType_Enums, gsi::arg ("other"), "@brief 'or' operator between two flag sets") +
  gsi::method_ext ("&", &qt_gsi::andopQTabletEvent_PointerType_Enums, gsi::arg ("other"), "@brief 'and' operator between two flag sets") +
  gsi::method_ext ("^", &qt_gsi::xoropQTabletEvent_PointerType_Enums, gsi::arg ("other"), "@brief 'xor' operator between two flag sets") +
  gsi::method_ext ("to_s|inspect", &qt_gsi::to_s_QTabletEvent_PointerType_Enums, "@brief Converts the flag set to a string") +
  gsi::method_ext ("to_i", &qt_gsi::to_i_QTabletEvent_PointerType_Enums, "@brief Returns the integer value encoding the flag set") +
  gsi::method_ext ("testFlag", &qt_gsi::testFlag_QTabletEvent_PointerType_Enums, gsi::arg ("flag"), "@brief Tests whether the flag is contained in the flag set"),
  "@qt\n@brief This class represents the QFlags<QTabletEvent::PointerType> flag set");

//  Declarations for enum wrapper class
gsi::Class<qt_gsi::QTabletEvent_PointerType_Enum> decl_QTabletEvent_PointerType_Enum (decl_QTabletEvent_PointerType_Enums, "QTabletEvent_PointerType",
  qt_gsi::mkdefs_QTabletEvent_PointerType () +
  gsi::method_ext ("to_s|inspect", &qt_gsi::to_s_QTabletEvent_PointerType_Enum, "@brief Converts the enum class to a string") +
  gsi::method_ext ("to_i", &qt_gsi::to_i_QTabletEvent_PointerType_Enum, "@brief Converts the enum class to an integer") +
  gsi::method_ext ("==", &qt_gsi::equalQTabletEvent_PointerType_Enum, gsi::arg ("other"), "@brief Compares the enum class against an enum of it's own type") +
  gsi::method_ext ("==", &qt_gsi::equal2QTabletEvent_PointerType_Enum, gsi::arg ("other"), "@brief Compares the enum class against an integer") +
  gsi::constructor ("new", &qt_gsi::from_i_QTabletEvent_PointerType_Enum, gsi::arg ("value"), "@brief Creates the enum object from an integer"),
  "@qt\n@brief This class represents the QTabletEvent::PointerType enum");

//  Inject the declarations into the parent
static gsi::ClassExt<QTabletEvent> inject_QTabletEvent_PointerType_Enum_in_parent (qt_gsi::mkdefs_QTabletEvent_PointerType ());
static gsi::ClassExt<QTabletEvent> decl_QTabletEvent_PointerType_Enum_as_child (decl_QTabletEvent_PointerType_Enum, "PointerType");

}


//  Implementation of the enum wrapper class for QTabletEvent::TabletDevice
namespace qt_gsi
{

static QTabletEvent_TabletDevice_Enum *c_1_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::NoDevice); }
static QTabletEvent_TabletDevice_Enum *c_2_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::Puck); }
static QTabletEvent_TabletDevice_Enum *c_3_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::Stylus); }
static QTabletEvent_TabletDevice_Enum *c_4_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::Airbrush); }
static QTabletEvent_TabletDevice_Enum *c_5_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::FourDMouse); }
static QTabletEvent_TabletDevice_Enum *c_6_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::XFreeEraser); }
static QTabletEvent_TabletDevice_Enum *c_7_QTabletEvent_TabletDevice_Enum () { return new QTabletEvent_TabletDevice_Enum (QTabletEvent::RotationStylus); }

static gsi::Methods mkdefs_QTabletEvent_TabletDevice () {
  return
    gsi::constant ("NoDevice", &qt_gsi::c_1_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::NoDevice") +
    gsi::constant ("Puck", &qt_gsi::c_2_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::Puck") +
    gsi::constant ("Stylus", &qt_gsi::c_3_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::Stylus") +
    gsi::constant ("Airbrush", &qt_gsi::c_4_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::Airbrush") +
    gsi::constant ("FourDMouse", &qt_gsi::c_5_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::FourDMouse") +
    gsi::constant ("XFreeEraser", &qt_gsi::c_6_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::XFreeEraser") +
    gsi::constant ("RotationStylus", &qt_gsi::c_7_QTabletEvent_TabletDevice_Enum, "@brief Enum constant QTabletEvent::RotationStylus");
}

static std::string to_s_QTabletEvent_TabletDevice_Enum (const QTabletEvent_TabletDevice_Enum *e)
{
  if (e->value () == QTabletEvent::NoDevice) { return tl::sprintf ("NoDevice (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Puck) { return tl::sprintf ("Puck (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Stylus) { return tl::sprintf ("Stylus (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::Airbrush) { return tl::sprintf ("Airbrush (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::FourDMouse) { return tl::sprintf ("FourDMouse (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::XFreeEraser) { return tl::sprintf ("XFreeEraser (%u)", (unsigned int) e->value ()); }
  if (e->value () == QTabletEvent::RotationStylus) { return tl::sprintf ("RotationStylus (%u)", (unsigned int) e->value ()); }
  return std::string ("(not a valid enum evalue)");
}

static unsigned int to_i_QTabletEvent_TabletDevice_Enum (const QTabletEvent_TabletDevice_Enum *e)
{
  return (unsigned int) e->value ();
}

static QTabletEvent_TabletDevice_Enum *from_i_QTabletEvent_TabletDevice_Enum (unsigned int i)
{
  return new QTabletEvent_TabletDevice_Enum ((QTabletEvent::TabletDevice) i);
}

static bool equalQTabletEvent_TabletDevice_Enum (const QTabletEvent_TabletDevice_Enum *e, QTabletEvent_TabletDevice_Enum d)
{
  return e->value () == d.value ();
}

static bool equal2QTabletEvent_TabletDevice_Enum (const QTabletEvent_TabletDevice_Enum *e, unsigned int i)
{
  return (unsigned int) e->value () == i;
}

static QTabletEvent_TabletDevice_Enums oropQTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e, const QTabletEvent_TabletDevice_Enums &d)
{
  return e->flags () | d.flags ();
}

static QTabletEvent_TabletDevice_Enums andopQTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e, const QTabletEvent_TabletDevice_Enums &d)
{
  return e->flags () & d.flags ();
}

static QTabletEvent_TabletDevice_Enums xoropQTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e, const QTabletEvent_TabletDevice_Enums &d)
{
  return e->flags () ^ d.flags ();
}

static std::string to_s_QTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e)
{
  std::string l;
  if (e->testFlag (QTabletEvent::NoDevice)) { if (!l.empty ()) l += "|"; l += "NoDevice"; }
  if (e->testFlag (QTabletEvent::Puck)) { if (!l.empty ()) l += "|"; l += "Puck"; }
  if (e->testFlag (QTabletEvent::Stylus)) { if (!l.empty ()) l += "|"; l += "Stylus"; }
  if (e->testFlag (QTabletEvent::Airbrush)) { if (!l.empty ()) l += "|"; l += "Airbrush"; }
  if (e->testFlag (QTabletEvent::FourDMouse)) { if (!l.empty ()) l += "|"; l += "FourDMouse"; }
  if (e->testFlag (QTabletEvent::XFreeEraser)) { if (!l.empty ()) l += "|"; l += "XFreeEraser"; }
  if (e->testFlag (QTabletEvent::RotationStylus)) { if (!l.empty ()) l += "|"; l += "RotationStylus"; }
  return tl::sprintf ("%u (%s)", (unsigned int) (e->flags ()), l);
}

static int to_i_QTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e)
{
  return int (e->flags ());
}

static bool testFlag_QTabletEvent_TabletDevice_Enums (const QTabletEvent_TabletDevice_Enums *e, const QTabletEvent_TabletDevice_Enum &d)
{
  return e->flags ().testFlag (d.value ());
}

}

namespace gsi
{

//  Declarations for QFlags<enum> wrapper class
gsi::Class<qt_gsi::QTabletEvent_TabletDevice_Enums> decl_QTabletEvent_TabletDevice_Enums ("QTabletEvent_QFlags_TabletDevice",
  gsi::method_ext ("|", &qt_gsi::oropQTabletEvent_TabletDevice_Enums, gsi::arg ("other"), "@brief 'or' operator between two flag sets") +
  gsi::method_ext ("&", &qt_gsi::andopQTabletEvent_TabletDevice_Enums, gsi::arg ("other"), "@brief 'and' operator between two flag sets") +
  gsi::method_ext ("^", &qt_gsi::xoropQTabletEvent_TabletDevice_Enums, gsi::arg ("other"), "@brief 'xor' operator between two flag sets") +
  gsi::method_ext ("to_s|inspect", &qt_gsi::to_s_QTabletEvent_TabletDevice_Enums, "@brief Converts the flag set to a string") +
  gsi::method_ext ("to_i", &qt_gsi::to_i_QTabletEvent_TabletDevice_Enums, "@brief Returns the integer value encoding the flag set") +
  gsi::method_ext ("testFlag", &qt_gsi::testFlag_QTabletEvent_TabletDevice_Enums, gsi::arg ("flag"), "@brief Tests whether the flag is contained in the flag set"),
  "@qt\n@brief This class represents the QFlags<QTabletEvent::TabletDevice> flag set");

//  Declarations for enum wrapper class
gsi::Class<qt_gsi::QTabletEvent_TabletDevice_Enum> decl_QTabletEvent_TabletDevice_Enum (decl_QTabletEvent_TabletDevice_Enums, "QTabletEvent_TabletDevice",
  qt_gsi::mkdefs_QTabletEvent_TabletDevice () +
  gsi::method_ext ("to_s|inspect", &qt_gsi::to_s_QTabletEvent_TabletDevice_Enum, "@brief Converts the enum class to a string") +
  gsi::method_ext ("to_i", &qt_gsi::to_i_QTabletEvent_TabletDevice_Enum, "@brief Converts the enum class to an integer") +
  gsi::method_ext ("==", &qt_gsi::equalQTabletEvent_TabletDevice_Enum, gsi::arg ("other"), "@brief Compares the enum class against an enum of it's own type") +
  gsi::method_ext ("==", &qt_gsi::equal2QTabletEvent_TabletDevice_Enum, gsi::arg ("other"), "@brief Compares the enum class against an integer") +
  gsi::constructor ("new", &qt_gsi::from_i_QTabletEvent_TabletDevice_Enum, gsi::arg ("value"), "@brief Creates the enum object from an integer"),
  "@qt\n@brief This class represents the QTabletEvent::TabletDevice enum");

//  Inject the declarations into the parent
static gsi::ClassExt<QTabletEvent> inject_QTabletEvent_TabletDevice_Enum_in_parent (qt_gsi::mkdefs_QTabletEvent_TabletDevice ());
static gsi::ClassExt<QTabletEvent> decl_QTabletEvent_TabletDevice_Enum_as_child (decl_QTabletEvent_TabletDevice_Enum, "TabletDevice");

}

