
/*

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

#ifndef _HDR_gsiDeclQt_Enums
#define _HDR_gsiDeclQt_Enums

#include <QtCore/QFlags>

namespace qt_gsi
{

//  Wrapper class for QFlags<enum Qt::AlignmentFlag>
class Qt_AlignmentFlag_Enums : public QFlags<enum Qt::AlignmentFlag> {
public:
  Qt_AlignmentFlag_Enums () : m_flags () { }
  Qt_AlignmentFlag_Enums (enum Qt::AlignmentFlag v) : m_flags (v) { }
  Qt_AlignmentFlag_Enums (const QFlags<enum Qt::AlignmentFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::AlignmentFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::AlignmentFlag> m_flags;
};

//  Wrapper class for enum Qt::AlignmentFlag
class Qt_AlignmentFlag_Enum : public Qt_AlignmentFlag_Enums {
public:
  Qt_AlignmentFlag_Enum () { }
  Qt_AlignmentFlag_Enum (enum Qt::AlignmentFlag v) : Qt_AlignmentFlag_Enums (v) { }
  enum Qt::AlignmentFlag value () const { return (enum Qt::AlignmentFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::AlignmentFlag>
template <>
struct Converter<QFlags<enum Qt::AlignmentFlag> >
{
public:
  typedef QFlags<enum Qt::AlignmentFlag> source_type;
  typedef Qt_AlignmentFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::AlignmentFlag
template <>
struct Converter<enum Qt::AlignmentFlag>
{
public:
  typedef enum Qt::AlignmentFlag source_type;
  typedef Qt_AlignmentFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::AnchorAttribute>
class Qt_AnchorAttribute_Enums : public QFlags<enum Qt::AnchorAttribute> {
public:
  Qt_AnchorAttribute_Enums () : m_flags () { }
  Qt_AnchorAttribute_Enums (enum Qt::AnchorAttribute v) : m_flags (v) { }
  Qt_AnchorAttribute_Enums (const QFlags<enum Qt::AnchorAttribute> &v) : m_flags (v) { }
  QFlags<enum Qt::AnchorAttribute> flags () const { return m_flags; }
private:
  QFlags<Qt::AnchorAttribute> m_flags;
};

//  Wrapper class for enum Qt::AnchorAttribute
class Qt_AnchorAttribute_Enum : public Qt_AnchorAttribute_Enums {
public:
  Qt_AnchorAttribute_Enum () { }
  Qt_AnchorAttribute_Enum (enum Qt::AnchorAttribute v) : Qt_AnchorAttribute_Enums (v) { }
  enum Qt::AnchorAttribute value () const { return (enum Qt::AnchorAttribute) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::AnchorAttribute>
template <>
struct Converter<QFlags<enum Qt::AnchorAttribute> >
{
public:
  typedef QFlags<enum Qt::AnchorAttribute> source_type;
  typedef Qt_AnchorAttribute_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::AnchorAttribute
template <>
struct Converter<enum Qt::AnchorAttribute>
{
public:
  typedef enum Qt::AnchorAttribute source_type;
  typedef Qt_AnchorAttribute_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::AnchorPoint>
class Qt_AnchorPoint_Enums : public QFlags<enum Qt::AnchorPoint> {
public:
  Qt_AnchorPoint_Enums () : m_flags () { }
  Qt_AnchorPoint_Enums (enum Qt::AnchorPoint v) : m_flags (v) { }
  Qt_AnchorPoint_Enums (const QFlags<enum Qt::AnchorPoint> &v) : m_flags (v) { }
  QFlags<enum Qt::AnchorPoint> flags () const { return m_flags; }
private:
  QFlags<Qt::AnchorPoint> m_flags;
};

//  Wrapper class for enum Qt::AnchorPoint
class Qt_AnchorPoint_Enum : public Qt_AnchorPoint_Enums {
public:
  Qt_AnchorPoint_Enum () { }
  Qt_AnchorPoint_Enum (enum Qt::AnchorPoint v) : Qt_AnchorPoint_Enums (v) { }
  enum Qt::AnchorPoint value () const { return (enum Qt::AnchorPoint) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::AnchorPoint>
template <>
struct Converter<QFlags<enum Qt::AnchorPoint> >
{
public:
  typedef QFlags<enum Qt::AnchorPoint> source_type;
  typedef Qt_AnchorPoint_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::AnchorPoint
template <>
struct Converter<enum Qt::AnchorPoint>
{
public:
  typedef enum Qt::AnchorPoint source_type;
  typedef Qt_AnchorPoint_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ApplicationAttribute>
class Qt_ApplicationAttribute_Enums : public QFlags<enum Qt::ApplicationAttribute> {
public:
  Qt_ApplicationAttribute_Enums () : m_flags () { }
  Qt_ApplicationAttribute_Enums (enum Qt::ApplicationAttribute v) : m_flags (v) { }
  Qt_ApplicationAttribute_Enums (const QFlags<enum Qt::ApplicationAttribute> &v) : m_flags (v) { }
  QFlags<enum Qt::ApplicationAttribute> flags () const { return m_flags; }
private:
  QFlags<Qt::ApplicationAttribute> m_flags;
};

//  Wrapper class for enum Qt::ApplicationAttribute
class Qt_ApplicationAttribute_Enum : public Qt_ApplicationAttribute_Enums {
public:
  Qt_ApplicationAttribute_Enum () { }
  Qt_ApplicationAttribute_Enum (enum Qt::ApplicationAttribute v) : Qt_ApplicationAttribute_Enums (v) { }
  enum Qt::ApplicationAttribute value () const { return (enum Qt::ApplicationAttribute) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ApplicationAttribute>
template <>
struct Converter<QFlags<enum Qt::ApplicationAttribute> >
{
public:
  typedef QFlags<enum Qt::ApplicationAttribute> source_type;
  typedef Qt_ApplicationAttribute_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ApplicationAttribute
template <>
struct Converter<enum Qt::ApplicationAttribute>
{
public:
  typedef enum Qt::ApplicationAttribute source_type;
  typedef Qt_ApplicationAttribute_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ArrowType>
class Qt_ArrowType_Enums : public QFlags<enum Qt::ArrowType> {
public:
  Qt_ArrowType_Enums () : m_flags () { }
  Qt_ArrowType_Enums (enum Qt::ArrowType v) : m_flags (v) { }
  Qt_ArrowType_Enums (const QFlags<enum Qt::ArrowType> &v) : m_flags (v) { }
  QFlags<enum Qt::ArrowType> flags () const { return m_flags; }
private:
  QFlags<Qt::ArrowType> m_flags;
};

//  Wrapper class for enum Qt::ArrowType
class Qt_ArrowType_Enum : public Qt_ArrowType_Enums {
public:
  Qt_ArrowType_Enum () { }
  Qt_ArrowType_Enum (enum Qt::ArrowType v) : Qt_ArrowType_Enums (v) { }
  enum Qt::ArrowType value () const { return (enum Qt::ArrowType) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ArrowType>
template <>
struct Converter<QFlags<enum Qt::ArrowType> >
{
public:
  typedef QFlags<enum Qt::ArrowType> source_type;
  typedef Qt_ArrowType_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ArrowType
template <>
struct Converter<enum Qt::ArrowType>
{
public:
  typedef enum Qt::ArrowType source_type;
  typedef Qt_ArrowType_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::AspectRatioMode>
class Qt_AspectRatioMode_Enums : public QFlags<enum Qt::AspectRatioMode> {
public:
  Qt_AspectRatioMode_Enums () : m_flags () { }
  Qt_AspectRatioMode_Enums (enum Qt::AspectRatioMode v) : m_flags (v) { }
  Qt_AspectRatioMode_Enums (const QFlags<enum Qt::AspectRatioMode> &v) : m_flags (v) { }
  QFlags<enum Qt::AspectRatioMode> flags () const { return m_flags; }
private:
  QFlags<Qt::AspectRatioMode> m_flags;
};

//  Wrapper class for enum Qt::AspectRatioMode
class Qt_AspectRatioMode_Enum : public Qt_AspectRatioMode_Enums {
public:
  Qt_AspectRatioMode_Enum () { }
  Qt_AspectRatioMode_Enum (enum Qt::AspectRatioMode v) : Qt_AspectRatioMode_Enums (v) { }
  enum Qt::AspectRatioMode value () const { return (enum Qt::AspectRatioMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::AspectRatioMode>
template <>
struct Converter<QFlags<enum Qt::AspectRatioMode> >
{
public:
  typedef QFlags<enum Qt::AspectRatioMode> source_type;
  typedef Qt_AspectRatioMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::AspectRatioMode
template <>
struct Converter<enum Qt::AspectRatioMode>
{
public:
  typedef enum Qt::AspectRatioMode source_type;
  typedef Qt_AspectRatioMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Axis>
class Qt_Axis_Enums : public QFlags<enum Qt::Axis> {
public:
  Qt_Axis_Enums () : m_flags () { }
  Qt_Axis_Enums (enum Qt::Axis v) : m_flags (v) { }
  Qt_Axis_Enums (const QFlags<enum Qt::Axis> &v) : m_flags (v) { }
  QFlags<enum Qt::Axis> flags () const { return m_flags; }
private:
  QFlags<Qt::Axis> m_flags;
};

//  Wrapper class for enum Qt::Axis
class Qt_Axis_Enum : public Qt_Axis_Enums {
public:
  Qt_Axis_Enum () { }
  Qt_Axis_Enum (enum Qt::Axis v) : Qt_Axis_Enums (v) { }
  enum Qt::Axis value () const { return (enum Qt::Axis) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Axis>
template <>
struct Converter<QFlags<enum Qt::Axis> >
{
public:
  typedef QFlags<enum Qt::Axis> source_type;
  typedef Qt_Axis_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Axis
template <>
struct Converter<enum Qt::Axis>
{
public:
  typedef enum Qt::Axis source_type;
  typedef Qt_Axis_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::BGMode>
class Qt_BGMode_Enums : public QFlags<enum Qt::BGMode> {
public:
  Qt_BGMode_Enums () : m_flags () { }
  Qt_BGMode_Enums (enum Qt::BGMode v) : m_flags (v) { }
  Qt_BGMode_Enums (const QFlags<enum Qt::BGMode> &v) : m_flags (v) { }
  QFlags<enum Qt::BGMode> flags () const { return m_flags; }
private:
  QFlags<Qt::BGMode> m_flags;
};

//  Wrapper class for enum Qt::BGMode
class Qt_BGMode_Enum : public Qt_BGMode_Enums {
public:
  Qt_BGMode_Enum () { }
  Qt_BGMode_Enum (enum Qt::BGMode v) : Qt_BGMode_Enums (v) { }
  enum Qt::BGMode value () const { return (enum Qt::BGMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::BGMode>
template <>
struct Converter<QFlags<enum Qt::BGMode> >
{
public:
  typedef QFlags<enum Qt::BGMode> source_type;
  typedef Qt_BGMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::BGMode
template <>
struct Converter<enum Qt::BGMode>
{
public:
  typedef enum Qt::BGMode source_type;
  typedef Qt_BGMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::BrushStyle>
class Qt_BrushStyle_Enums : public QFlags<enum Qt::BrushStyle> {
public:
  Qt_BrushStyle_Enums () : m_flags () { }
  Qt_BrushStyle_Enums (enum Qt::BrushStyle v) : m_flags (v) { }
  Qt_BrushStyle_Enums (const QFlags<enum Qt::BrushStyle> &v) : m_flags (v) { }
  QFlags<enum Qt::BrushStyle> flags () const { return m_flags; }
private:
  QFlags<Qt::BrushStyle> m_flags;
};

//  Wrapper class for enum Qt::BrushStyle
class Qt_BrushStyle_Enum : public Qt_BrushStyle_Enums {
public:
  Qt_BrushStyle_Enum () { }
  Qt_BrushStyle_Enum (enum Qt::BrushStyle v) : Qt_BrushStyle_Enums (v) { }
  enum Qt::BrushStyle value () const { return (enum Qt::BrushStyle) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::BrushStyle>
template <>
struct Converter<QFlags<enum Qt::BrushStyle> >
{
public:
  typedef QFlags<enum Qt::BrushStyle> source_type;
  typedef Qt_BrushStyle_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::BrushStyle
template <>
struct Converter<enum Qt::BrushStyle>
{
public:
  typedef enum Qt::BrushStyle source_type;
  typedef Qt_BrushStyle_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::CaseSensitivity>
class Qt_CaseSensitivity_Enums : public QFlags<enum Qt::CaseSensitivity> {
public:
  Qt_CaseSensitivity_Enums () : m_flags () { }
  Qt_CaseSensitivity_Enums (enum Qt::CaseSensitivity v) : m_flags (v) { }
  Qt_CaseSensitivity_Enums (const QFlags<enum Qt::CaseSensitivity> &v) : m_flags (v) { }
  QFlags<enum Qt::CaseSensitivity> flags () const { return m_flags; }
private:
  QFlags<Qt::CaseSensitivity> m_flags;
};

//  Wrapper class for enum Qt::CaseSensitivity
class Qt_CaseSensitivity_Enum : public Qt_CaseSensitivity_Enums {
public:
  Qt_CaseSensitivity_Enum () { }
  Qt_CaseSensitivity_Enum (enum Qt::CaseSensitivity v) : Qt_CaseSensitivity_Enums (v) { }
  enum Qt::CaseSensitivity value () const { return (enum Qt::CaseSensitivity) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::CaseSensitivity>
template <>
struct Converter<QFlags<enum Qt::CaseSensitivity> >
{
public:
  typedef QFlags<enum Qt::CaseSensitivity> source_type;
  typedef Qt_CaseSensitivity_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::CaseSensitivity
template <>
struct Converter<enum Qt::CaseSensitivity>
{
public:
  typedef enum Qt::CaseSensitivity source_type;
  typedef Qt_CaseSensitivity_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::CheckState>
class Qt_CheckState_Enums : public QFlags<enum Qt::CheckState> {
public:
  Qt_CheckState_Enums () : m_flags () { }
  Qt_CheckState_Enums (enum Qt::CheckState v) : m_flags (v) { }
  Qt_CheckState_Enums (const QFlags<enum Qt::CheckState> &v) : m_flags (v) { }
  QFlags<enum Qt::CheckState> flags () const { return m_flags; }
private:
  QFlags<Qt::CheckState> m_flags;
};

//  Wrapper class for enum Qt::CheckState
class Qt_CheckState_Enum : public Qt_CheckState_Enums {
public:
  Qt_CheckState_Enum () { }
  Qt_CheckState_Enum (enum Qt::CheckState v) : Qt_CheckState_Enums (v) { }
  enum Qt::CheckState value () const { return (enum Qt::CheckState) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::CheckState>
template <>
struct Converter<QFlags<enum Qt::CheckState> >
{
public:
  typedef QFlags<enum Qt::CheckState> source_type;
  typedef Qt_CheckState_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::CheckState
template <>
struct Converter<enum Qt::CheckState>
{
public:
  typedef enum Qt::CheckState source_type;
  typedef Qt_CheckState_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ClipOperation>
class Qt_ClipOperation_Enums : public QFlags<enum Qt::ClipOperation> {
public:
  Qt_ClipOperation_Enums () : m_flags () { }
  Qt_ClipOperation_Enums (enum Qt::ClipOperation v) : m_flags (v) { }
  Qt_ClipOperation_Enums (const QFlags<enum Qt::ClipOperation> &v) : m_flags (v) { }
  QFlags<enum Qt::ClipOperation> flags () const { return m_flags; }
private:
  QFlags<Qt::ClipOperation> m_flags;
};

//  Wrapper class for enum Qt::ClipOperation
class Qt_ClipOperation_Enum : public Qt_ClipOperation_Enums {
public:
  Qt_ClipOperation_Enum () { }
  Qt_ClipOperation_Enum (enum Qt::ClipOperation v) : Qt_ClipOperation_Enums (v) { }
  enum Qt::ClipOperation value () const { return (enum Qt::ClipOperation) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ClipOperation>
template <>
struct Converter<QFlags<enum Qt::ClipOperation> >
{
public:
  typedef QFlags<enum Qt::ClipOperation> source_type;
  typedef Qt_ClipOperation_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ClipOperation
template <>
struct Converter<enum Qt::ClipOperation>
{
public:
  typedef enum Qt::ClipOperation source_type;
  typedef Qt_ClipOperation_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ConnectionType>
class Qt_ConnectionType_Enums : public QFlags<enum Qt::ConnectionType> {
public:
  Qt_ConnectionType_Enums () : m_flags () { }
  Qt_ConnectionType_Enums (enum Qt::ConnectionType v) : m_flags (v) { }
  Qt_ConnectionType_Enums (const QFlags<enum Qt::ConnectionType> &v) : m_flags (v) { }
  QFlags<enum Qt::ConnectionType> flags () const { return m_flags; }
private:
  QFlags<Qt::ConnectionType> m_flags;
};

//  Wrapper class for enum Qt::ConnectionType
class Qt_ConnectionType_Enum : public Qt_ConnectionType_Enums {
public:
  Qt_ConnectionType_Enum () { }
  Qt_ConnectionType_Enum (enum Qt::ConnectionType v) : Qt_ConnectionType_Enums (v) { }
  enum Qt::ConnectionType value () const { return (enum Qt::ConnectionType) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ConnectionType>
template <>
struct Converter<QFlags<enum Qt::ConnectionType> >
{
public:
  typedef QFlags<enum Qt::ConnectionType> source_type;
  typedef Qt_ConnectionType_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ConnectionType
template <>
struct Converter<enum Qt::ConnectionType>
{
public:
  typedef enum Qt::ConnectionType source_type;
  typedef Qt_ConnectionType_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ContextMenuPolicy>
class Qt_ContextMenuPolicy_Enums : public QFlags<enum Qt::ContextMenuPolicy> {
public:
  Qt_ContextMenuPolicy_Enums () : m_flags () { }
  Qt_ContextMenuPolicy_Enums (enum Qt::ContextMenuPolicy v) : m_flags (v) { }
  Qt_ContextMenuPolicy_Enums (const QFlags<enum Qt::ContextMenuPolicy> &v) : m_flags (v) { }
  QFlags<enum Qt::ContextMenuPolicy> flags () const { return m_flags; }
private:
  QFlags<Qt::ContextMenuPolicy> m_flags;
};

//  Wrapper class for enum Qt::ContextMenuPolicy
class Qt_ContextMenuPolicy_Enum : public Qt_ContextMenuPolicy_Enums {
public:
  Qt_ContextMenuPolicy_Enum () { }
  Qt_ContextMenuPolicy_Enum (enum Qt::ContextMenuPolicy v) : Qt_ContextMenuPolicy_Enums (v) { }
  enum Qt::ContextMenuPolicy value () const { return (enum Qt::ContextMenuPolicy) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ContextMenuPolicy>
template <>
struct Converter<QFlags<enum Qt::ContextMenuPolicy> >
{
public:
  typedef QFlags<enum Qt::ContextMenuPolicy> source_type;
  typedef Qt_ContextMenuPolicy_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ContextMenuPolicy
template <>
struct Converter<enum Qt::ContextMenuPolicy>
{
public:
  typedef enum Qt::ContextMenuPolicy source_type;
  typedef Qt_ContextMenuPolicy_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::CoordinateSystem>
class Qt_CoordinateSystem_Enums : public QFlags<enum Qt::CoordinateSystem> {
public:
  Qt_CoordinateSystem_Enums () : m_flags () { }
  Qt_CoordinateSystem_Enums (enum Qt::CoordinateSystem v) : m_flags (v) { }
  Qt_CoordinateSystem_Enums (const QFlags<enum Qt::CoordinateSystem> &v) : m_flags (v) { }
  QFlags<enum Qt::CoordinateSystem> flags () const { return m_flags; }
private:
  QFlags<Qt::CoordinateSystem> m_flags;
};

//  Wrapper class for enum Qt::CoordinateSystem
class Qt_CoordinateSystem_Enum : public Qt_CoordinateSystem_Enums {
public:
  Qt_CoordinateSystem_Enum () { }
  Qt_CoordinateSystem_Enum (enum Qt::CoordinateSystem v) : Qt_CoordinateSystem_Enums (v) { }
  enum Qt::CoordinateSystem value () const { return (enum Qt::CoordinateSystem) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::CoordinateSystem>
template <>
struct Converter<QFlags<enum Qt::CoordinateSystem> >
{
public:
  typedef QFlags<enum Qt::CoordinateSystem> source_type;
  typedef Qt_CoordinateSystem_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::CoordinateSystem
template <>
struct Converter<enum Qt::CoordinateSystem>
{
public:
  typedef enum Qt::CoordinateSystem source_type;
  typedef Qt_CoordinateSystem_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Corner>
class Qt_Corner_Enums : public QFlags<enum Qt::Corner> {
public:
  Qt_Corner_Enums () : m_flags () { }
  Qt_Corner_Enums (enum Qt::Corner v) : m_flags (v) { }
  Qt_Corner_Enums (const QFlags<enum Qt::Corner> &v) : m_flags (v) { }
  QFlags<enum Qt::Corner> flags () const { return m_flags; }
private:
  QFlags<Qt::Corner> m_flags;
};

//  Wrapper class for enum Qt::Corner
class Qt_Corner_Enum : public Qt_Corner_Enums {
public:
  Qt_Corner_Enum () { }
  Qt_Corner_Enum (enum Qt::Corner v) : Qt_Corner_Enums (v) { }
  enum Qt::Corner value () const { return (enum Qt::Corner) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Corner>
template <>
struct Converter<QFlags<enum Qt::Corner> >
{
public:
  typedef QFlags<enum Qt::Corner> source_type;
  typedef Qt_Corner_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Corner
template <>
struct Converter<enum Qt::Corner>
{
public:
  typedef enum Qt::Corner source_type;
  typedef Qt_Corner_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::CursorShape>
class Qt_CursorShape_Enums : public QFlags<enum Qt::CursorShape> {
public:
  Qt_CursorShape_Enums () : m_flags () { }
  Qt_CursorShape_Enums (enum Qt::CursorShape v) : m_flags (v) { }
  Qt_CursorShape_Enums (const QFlags<enum Qt::CursorShape> &v) : m_flags (v) { }
  QFlags<enum Qt::CursorShape> flags () const { return m_flags; }
private:
  QFlags<Qt::CursorShape> m_flags;
};

//  Wrapper class for enum Qt::CursorShape
class Qt_CursorShape_Enum : public Qt_CursorShape_Enums {
public:
  Qt_CursorShape_Enum () { }
  Qt_CursorShape_Enum (enum Qt::CursorShape v) : Qt_CursorShape_Enums (v) { }
  enum Qt::CursorShape value () const { return (enum Qt::CursorShape) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::CursorShape>
template <>
struct Converter<QFlags<enum Qt::CursorShape> >
{
public:
  typedef QFlags<enum Qt::CursorShape> source_type;
  typedef Qt_CursorShape_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::CursorShape
template <>
struct Converter<enum Qt::CursorShape>
{
public:
  typedef enum Qt::CursorShape source_type;
  typedef Qt_CursorShape_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::DateFormat>
class Qt_DateFormat_Enums : public QFlags<enum Qt::DateFormat> {
public:
  Qt_DateFormat_Enums () : m_flags () { }
  Qt_DateFormat_Enums (enum Qt::DateFormat v) : m_flags (v) { }
  Qt_DateFormat_Enums (const QFlags<enum Qt::DateFormat> &v) : m_flags (v) { }
  QFlags<enum Qt::DateFormat> flags () const { return m_flags; }
private:
  QFlags<Qt::DateFormat> m_flags;
};

//  Wrapper class for enum Qt::DateFormat
class Qt_DateFormat_Enum : public Qt_DateFormat_Enums {
public:
  Qt_DateFormat_Enum () { }
  Qt_DateFormat_Enum (enum Qt::DateFormat v) : Qt_DateFormat_Enums (v) { }
  enum Qt::DateFormat value () const { return (enum Qt::DateFormat) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::DateFormat>
template <>
struct Converter<QFlags<enum Qt::DateFormat> >
{
public:
  typedef QFlags<enum Qt::DateFormat> source_type;
  typedef Qt_DateFormat_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::DateFormat
template <>
struct Converter<enum Qt::DateFormat>
{
public:
  typedef enum Qt::DateFormat source_type;
  typedef Qt_DateFormat_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::DayOfWeek>
class Qt_DayOfWeek_Enums : public QFlags<enum Qt::DayOfWeek> {
public:
  Qt_DayOfWeek_Enums () : m_flags () { }
  Qt_DayOfWeek_Enums (enum Qt::DayOfWeek v) : m_flags (v) { }
  Qt_DayOfWeek_Enums (const QFlags<enum Qt::DayOfWeek> &v) : m_flags (v) { }
  QFlags<enum Qt::DayOfWeek> flags () const { return m_flags; }
private:
  QFlags<Qt::DayOfWeek> m_flags;
};

//  Wrapper class for enum Qt::DayOfWeek
class Qt_DayOfWeek_Enum : public Qt_DayOfWeek_Enums {
public:
  Qt_DayOfWeek_Enum () { }
  Qt_DayOfWeek_Enum (enum Qt::DayOfWeek v) : Qt_DayOfWeek_Enums (v) { }
  enum Qt::DayOfWeek value () const { return (enum Qt::DayOfWeek) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::DayOfWeek>
template <>
struct Converter<QFlags<enum Qt::DayOfWeek> >
{
public:
  typedef QFlags<enum Qt::DayOfWeek> source_type;
  typedef Qt_DayOfWeek_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::DayOfWeek
template <>
struct Converter<enum Qt::DayOfWeek>
{
public:
  typedef enum Qt::DayOfWeek source_type;
  typedef Qt_DayOfWeek_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::DockWidgetArea>
class Qt_DockWidgetArea_Enums : public QFlags<enum Qt::DockWidgetArea> {
public:
  Qt_DockWidgetArea_Enums () : m_flags () { }
  Qt_DockWidgetArea_Enums (enum Qt::DockWidgetArea v) : m_flags (v) { }
  Qt_DockWidgetArea_Enums (const QFlags<enum Qt::DockWidgetArea> &v) : m_flags (v) { }
  QFlags<enum Qt::DockWidgetArea> flags () const { return m_flags; }
private:
  QFlags<Qt::DockWidgetArea> m_flags;
};

//  Wrapper class for enum Qt::DockWidgetArea
class Qt_DockWidgetArea_Enum : public Qt_DockWidgetArea_Enums {
public:
  Qt_DockWidgetArea_Enum () { }
  Qt_DockWidgetArea_Enum (enum Qt::DockWidgetArea v) : Qt_DockWidgetArea_Enums (v) { }
  enum Qt::DockWidgetArea value () const { return (enum Qt::DockWidgetArea) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::DockWidgetArea>
template <>
struct Converter<QFlags<enum Qt::DockWidgetArea> >
{
public:
  typedef QFlags<enum Qt::DockWidgetArea> source_type;
  typedef Qt_DockWidgetArea_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::DockWidgetArea
template <>
struct Converter<enum Qt::DockWidgetArea>
{
public:
  typedef enum Qt::DockWidgetArea source_type;
  typedef Qt_DockWidgetArea_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::DockWidgetAreaSizes>
class Qt_DockWidgetAreaSizes_Enums : public QFlags<enum Qt::DockWidgetAreaSizes> {
public:
  Qt_DockWidgetAreaSizes_Enums () : m_flags () { }
  Qt_DockWidgetAreaSizes_Enums (enum Qt::DockWidgetAreaSizes v) : m_flags (v) { }
  Qt_DockWidgetAreaSizes_Enums (const QFlags<enum Qt::DockWidgetAreaSizes> &v) : m_flags (v) { }
  QFlags<enum Qt::DockWidgetAreaSizes> flags () const { return m_flags; }
private:
  QFlags<Qt::DockWidgetAreaSizes> m_flags;
};

//  Wrapper class for enum Qt::DockWidgetAreaSizes
class Qt_DockWidgetAreaSizes_Enum : public Qt_DockWidgetAreaSizes_Enums {
public:
  Qt_DockWidgetAreaSizes_Enum () { }
  Qt_DockWidgetAreaSizes_Enum (enum Qt::DockWidgetAreaSizes v) : Qt_DockWidgetAreaSizes_Enums (v) { }
  enum Qt::DockWidgetAreaSizes value () const { return (enum Qt::DockWidgetAreaSizes) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::DockWidgetAreaSizes>
template <>
struct Converter<QFlags<enum Qt::DockWidgetAreaSizes> >
{
public:
  typedef QFlags<enum Qt::DockWidgetAreaSizes> source_type;
  typedef Qt_DockWidgetAreaSizes_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::DockWidgetAreaSizes
template <>
struct Converter<enum Qt::DockWidgetAreaSizes>
{
public:
  typedef enum Qt::DockWidgetAreaSizes source_type;
  typedef Qt_DockWidgetAreaSizes_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::DropAction>
class Qt_DropAction_Enums : public QFlags<enum Qt::DropAction> {
public:
  Qt_DropAction_Enums () : m_flags () { }
  Qt_DropAction_Enums (enum Qt::DropAction v) : m_flags (v) { }
  Qt_DropAction_Enums (const QFlags<enum Qt::DropAction> &v) : m_flags (v) { }
  QFlags<enum Qt::DropAction> flags () const { return m_flags; }
private:
  QFlags<Qt::DropAction> m_flags;
};

//  Wrapper class for enum Qt::DropAction
class Qt_DropAction_Enum : public Qt_DropAction_Enums {
public:
  Qt_DropAction_Enum () { }
  Qt_DropAction_Enum (enum Qt::DropAction v) : Qt_DropAction_Enums (v) { }
  enum Qt::DropAction value () const { return (enum Qt::DropAction) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::DropAction>
template <>
struct Converter<QFlags<enum Qt::DropAction> >
{
public:
  typedef QFlags<enum Qt::DropAction> source_type;
  typedef Qt_DropAction_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::DropAction
template <>
struct Converter<enum Qt::DropAction>
{
public:
  typedef enum Qt::DropAction source_type;
  typedef Qt_DropAction_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::EventPriority>
class Qt_EventPriority_Enums : public QFlags<enum Qt::EventPriority> {
public:
  Qt_EventPriority_Enums () : m_flags () { }
  Qt_EventPriority_Enums (enum Qt::EventPriority v) : m_flags (v) { }
  Qt_EventPriority_Enums (const QFlags<enum Qt::EventPriority> &v) : m_flags (v) { }
  QFlags<enum Qt::EventPriority> flags () const { return m_flags; }
private:
  QFlags<Qt::EventPriority> m_flags;
};

//  Wrapper class for enum Qt::EventPriority
class Qt_EventPriority_Enum : public Qt_EventPriority_Enums {
public:
  Qt_EventPriority_Enum () { }
  Qt_EventPriority_Enum (enum Qt::EventPriority v) : Qt_EventPriority_Enums (v) { }
  enum Qt::EventPriority value () const { return (enum Qt::EventPriority) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::EventPriority>
template <>
struct Converter<QFlags<enum Qt::EventPriority> >
{
public:
  typedef QFlags<enum Qt::EventPriority> source_type;
  typedef Qt_EventPriority_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::EventPriority
template <>
struct Converter<enum Qt::EventPriority>
{
public:
  typedef enum Qt::EventPriority source_type;
  typedef Qt_EventPriority_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::FillRule>
class Qt_FillRule_Enums : public QFlags<enum Qt::FillRule> {
public:
  Qt_FillRule_Enums () : m_flags () { }
  Qt_FillRule_Enums (enum Qt::FillRule v) : m_flags (v) { }
  Qt_FillRule_Enums (const QFlags<enum Qt::FillRule> &v) : m_flags (v) { }
  QFlags<enum Qt::FillRule> flags () const { return m_flags; }
private:
  QFlags<Qt::FillRule> m_flags;
};

//  Wrapper class for enum Qt::FillRule
class Qt_FillRule_Enum : public Qt_FillRule_Enums {
public:
  Qt_FillRule_Enum () { }
  Qt_FillRule_Enum (enum Qt::FillRule v) : Qt_FillRule_Enums (v) { }
  enum Qt::FillRule value () const { return (enum Qt::FillRule) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::FillRule>
template <>
struct Converter<QFlags<enum Qt::FillRule> >
{
public:
  typedef QFlags<enum Qt::FillRule> source_type;
  typedef Qt_FillRule_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::FillRule
template <>
struct Converter<enum Qt::FillRule>
{
public:
  typedef enum Qt::FillRule source_type;
  typedef Qt_FillRule_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::FocusPolicy>
class Qt_FocusPolicy_Enums : public QFlags<enum Qt::FocusPolicy> {
public:
  Qt_FocusPolicy_Enums () : m_flags () { }
  Qt_FocusPolicy_Enums (enum Qt::FocusPolicy v) : m_flags (v) { }
  Qt_FocusPolicy_Enums (const QFlags<enum Qt::FocusPolicy> &v) : m_flags (v) { }
  QFlags<enum Qt::FocusPolicy> flags () const { return m_flags; }
private:
  QFlags<Qt::FocusPolicy> m_flags;
};

//  Wrapper class for enum Qt::FocusPolicy
class Qt_FocusPolicy_Enum : public Qt_FocusPolicy_Enums {
public:
  Qt_FocusPolicy_Enum () { }
  Qt_FocusPolicy_Enum (enum Qt::FocusPolicy v) : Qt_FocusPolicy_Enums (v) { }
  enum Qt::FocusPolicy value () const { return (enum Qt::FocusPolicy) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::FocusPolicy>
template <>
struct Converter<QFlags<enum Qt::FocusPolicy> >
{
public:
  typedef QFlags<enum Qt::FocusPolicy> source_type;
  typedef Qt_FocusPolicy_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::FocusPolicy
template <>
struct Converter<enum Qt::FocusPolicy>
{
public:
  typedef enum Qt::FocusPolicy source_type;
  typedef Qt_FocusPolicy_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::FocusReason>
class Qt_FocusReason_Enums : public QFlags<enum Qt::FocusReason> {
public:
  Qt_FocusReason_Enums () : m_flags () { }
  Qt_FocusReason_Enums (enum Qt::FocusReason v) : m_flags (v) { }
  Qt_FocusReason_Enums (const QFlags<enum Qt::FocusReason> &v) : m_flags (v) { }
  QFlags<enum Qt::FocusReason> flags () const { return m_flags; }
private:
  QFlags<Qt::FocusReason> m_flags;
};

//  Wrapper class for enum Qt::FocusReason
class Qt_FocusReason_Enum : public Qt_FocusReason_Enums {
public:
  Qt_FocusReason_Enum () { }
  Qt_FocusReason_Enum (enum Qt::FocusReason v) : Qt_FocusReason_Enums (v) { }
  enum Qt::FocusReason value () const { return (enum Qt::FocusReason) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::FocusReason>
template <>
struct Converter<QFlags<enum Qt::FocusReason> >
{
public:
  typedef QFlags<enum Qt::FocusReason> source_type;
  typedef Qt_FocusReason_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::FocusReason
template <>
struct Converter<enum Qt::FocusReason>
{
public:
  typedef enum Qt::FocusReason source_type;
  typedef Qt_FocusReason_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::GestureFlag>
class Qt_GestureFlag_Enums : public QFlags<enum Qt::GestureFlag> {
public:
  Qt_GestureFlag_Enums () : m_flags () { }
  Qt_GestureFlag_Enums (enum Qt::GestureFlag v) : m_flags (v) { }
  Qt_GestureFlag_Enums (const QFlags<enum Qt::GestureFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::GestureFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::GestureFlag> m_flags;
};

//  Wrapper class for enum Qt::GestureFlag
class Qt_GestureFlag_Enum : public Qt_GestureFlag_Enums {
public:
  Qt_GestureFlag_Enum () { }
  Qt_GestureFlag_Enum (enum Qt::GestureFlag v) : Qt_GestureFlag_Enums (v) { }
  enum Qt::GestureFlag value () const { return (enum Qt::GestureFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::GestureFlag>
template <>
struct Converter<QFlags<enum Qt::GestureFlag> >
{
public:
  typedef QFlags<enum Qt::GestureFlag> source_type;
  typedef Qt_GestureFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::GestureFlag
template <>
struct Converter<enum Qt::GestureFlag>
{
public:
  typedef enum Qt::GestureFlag source_type;
  typedef Qt_GestureFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::GestureState>
class Qt_GestureState_Enums : public QFlags<enum Qt::GestureState> {
public:
  Qt_GestureState_Enums () : m_flags () { }
  Qt_GestureState_Enums (enum Qt::GestureState v) : m_flags (v) { }
  Qt_GestureState_Enums (const QFlags<enum Qt::GestureState> &v) : m_flags (v) { }
  QFlags<enum Qt::GestureState> flags () const { return m_flags; }
private:
  QFlags<Qt::GestureState> m_flags;
};

//  Wrapper class for enum Qt::GestureState
class Qt_GestureState_Enum : public Qt_GestureState_Enums {
public:
  Qt_GestureState_Enum () { }
  Qt_GestureState_Enum (enum Qt::GestureState v) : Qt_GestureState_Enums (v) { }
  enum Qt::GestureState value () const { return (enum Qt::GestureState) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::GestureState>
template <>
struct Converter<QFlags<enum Qt::GestureState> >
{
public:
  typedef QFlags<enum Qt::GestureState> source_type;
  typedef Qt_GestureState_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::GestureState
template <>
struct Converter<enum Qt::GestureState>
{
public:
  typedef enum Qt::GestureState source_type;
  typedef Qt_GestureState_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::GestureType>
class Qt_GestureType_Enums : public QFlags<enum Qt::GestureType> {
public:
  Qt_GestureType_Enums () : m_flags () { }
  Qt_GestureType_Enums (enum Qt::GestureType v) : m_flags (v) { }
  Qt_GestureType_Enums (const QFlags<enum Qt::GestureType> &v) : m_flags (v) { }
  QFlags<enum Qt::GestureType> flags () const { return m_flags; }
private:
  QFlags<Qt::GestureType> m_flags;
};

//  Wrapper class for enum Qt::GestureType
class Qt_GestureType_Enum : public Qt_GestureType_Enums {
public:
  Qt_GestureType_Enum () { }
  Qt_GestureType_Enum (enum Qt::GestureType v) : Qt_GestureType_Enums (v) { }
  enum Qt::GestureType value () const { return (enum Qt::GestureType) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::GestureType>
template <>
struct Converter<QFlags<enum Qt::GestureType> >
{
public:
  typedef QFlags<enum Qt::GestureType> source_type;
  typedef Qt_GestureType_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::GestureType
template <>
struct Converter<enum Qt::GestureType>
{
public:
  typedef enum Qt::GestureType source_type;
  typedef Qt_GestureType_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::GlobalColor>
class Qt_GlobalColor_Enums : public QFlags<enum Qt::GlobalColor> {
public:
  Qt_GlobalColor_Enums () : m_flags () { }
  Qt_GlobalColor_Enums (enum Qt::GlobalColor v) : m_flags (v) { }
  Qt_GlobalColor_Enums (const QFlags<enum Qt::GlobalColor> &v) : m_flags (v) { }
  QFlags<enum Qt::GlobalColor> flags () const { return m_flags; }
private:
  QFlags<Qt::GlobalColor> m_flags;
};

//  Wrapper class for enum Qt::GlobalColor
class Qt_GlobalColor_Enum : public Qt_GlobalColor_Enums {
public:
  Qt_GlobalColor_Enum () { }
  Qt_GlobalColor_Enum (enum Qt::GlobalColor v) : Qt_GlobalColor_Enums (v) { }
  enum Qt::GlobalColor value () const { return (enum Qt::GlobalColor) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::GlobalColor>
template <>
struct Converter<QFlags<enum Qt::GlobalColor> >
{
public:
  typedef QFlags<enum Qt::GlobalColor> source_type;
  typedef Qt_GlobalColor_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::GlobalColor
template <>
struct Converter<enum Qt::GlobalColor>
{
public:
  typedef enum Qt::GlobalColor source_type;
  typedef Qt_GlobalColor_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::HitTestAccuracy>
class Qt_HitTestAccuracy_Enums : public QFlags<enum Qt::HitTestAccuracy> {
public:
  Qt_HitTestAccuracy_Enums () : m_flags () { }
  Qt_HitTestAccuracy_Enums (enum Qt::HitTestAccuracy v) : m_flags (v) { }
  Qt_HitTestAccuracy_Enums (const QFlags<enum Qt::HitTestAccuracy> &v) : m_flags (v) { }
  QFlags<enum Qt::HitTestAccuracy> flags () const { return m_flags; }
private:
  QFlags<Qt::HitTestAccuracy> m_flags;
};

//  Wrapper class for enum Qt::HitTestAccuracy
class Qt_HitTestAccuracy_Enum : public Qt_HitTestAccuracy_Enums {
public:
  Qt_HitTestAccuracy_Enum () { }
  Qt_HitTestAccuracy_Enum (enum Qt::HitTestAccuracy v) : Qt_HitTestAccuracy_Enums (v) { }
  enum Qt::HitTestAccuracy value () const { return (enum Qt::HitTestAccuracy) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::HitTestAccuracy>
template <>
struct Converter<QFlags<enum Qt::HitTestAccuracy> >
{
public:
  typedef QFlags<enum Qt::HitTestAccuracy> source_type;
  typedef Qt_HitTestAccuracy_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::HitTestAccuracy
template <>
struct Converter<enum Qt::HitTestAccuracy>
{
public:
  typedef enum Qt::HitTestAccuracy source_type;
  typedef Qt_HitTestAccuracy_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ImageConversionFlag>
class Qt_ImageConversionFlag_Enums : public QFlags<enum Qt::ImageConversionFlag> {
public:
  Qt_ImageConversionFlag_Enums () : m_flags () { }
  Qt_ImageConversionFlag_Enums (enum Qt::ImageConversionFlag v) : m_flags (v) { }
  Qt_ImageConversionFlag_Enums (const QFlags<enum Qt::ImageConversionFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::ImageConversionFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::ImageConversionFlag> m_flags;
};

//  Wrapper class for enum Qt::ImageConversionFlag
class Qt_ImageConversionFlag_Enum : public Qt_ImageConversionFlag_Enums {
public:
  Qt_ImageConversionFlag_Enum () { }
  Qt_ImageConversionFlag_Enum (enum Qt::ImageConversionFlag v) : Qt_ImageConversionFlag_Enums (v) { }
  enum Qt::ImageConversionFlag value () const { return (enum Qt::ImageConversionFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ImageConversionFlag>
template <>
struct Converter<QFlags<enum Qt::ImageConversionFlag> >
{
public:
  typedef QFlags<enum Qt::ImageConversionFlag> source_type;
  typedef Qt_ImageConversionFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ImageConversionFlag
template <>
struct Converter<enum Qt::ImageConversionFlag>
{
public:
  typedef enum Qt::ImageConversionFlag source_type;
  typedef Qt_ImageConversionFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Initialization>
class Qt_Initialization_Enums : public QFlags<enum Qt::Initialization> {
public:
  Qt_Initialization_Enums () : m_flags () { }
  Qt_Initialization_Enums (enum Qt::Initialization v) : m_flags (v) { }
  Qt_Initialization_Enums (const QFlags<enum Qt::Initialization> &v) : m_flags (v) { }
  QFlags<enum Qt::Initialization> flags () const { return m_flags; }
private:
  QFlags<Qt::Initialization> m_flags;
};

//  Wrapper class for enum Qt::Initialization
class Qt_Initialization_Enum : public Qt_Initialization_Enums {
public:
  Qt_Initialization_Enum () { }
  Qt_Initialization_Enum (enum Qt::Initialization v) : Qt_Initialization_Enums (v) { }
  enum Qt::Initialization value () const { return (enum Qt::Initialization) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Initialization>
template <>
struct Converter<QFlags<enum Qt::Initialization> >
{
public:
  typedef QFlags<enum Qt::Initialization> source_type;
  typedef Qt_Initialization_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Initialization
template <>
struct Converter<enum Qt::Initialization>
{
public:
  typedef enum Qt::Initialization source_type;
  typedef Qt_Initialization_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::InputMethodHint>
class Qt_InputMethodHint_Enums : public QFlags<enum Qt::InputMethodHint> {
public:
  Qt_InputMethodHint_Enums () : m_flags () { }
  Qt_InputMethodHint_Enums (enum Qt::InputMethodHint v) : m_flags (v) { }
  Qt_InputMethodHint_Enums (const QFlags<enum Qt::InputMethodHint> &v) : m_flags (v) { }
  QFlags<enum Qt::InputMethodHint> flags () const { return m_flags; }
private:
  QFlags<Qt::InputMethodHint> m_flags;
};

//  Wrapper class for enum Qt::InputMethodHint
class Qt_InputMethodHint_Enum : public Qt_InputMethodHint_Enums {
public:
  Qt_InputMethodHint_Enum () { }
  Qt_InputMethodHint_Enum (enum Qt::InputMethodHint v) : Qt_InputMethodHint_Enums (v) { }
  enum Qt::InputMethodHint value () const { return (enum Qt::InputMethodHint) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::InputMethodHint>
template <>
struct Converter<QFlags<enum Qt::InputMethodHint> >
{
public:
  typedef QFlags<enum Qt::InputMethodHint> source_type;
  typedef Qt_InputMethodHint_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::InputMethodHint
template <>
struct Converter<enum Qt::InputMethodHint>
{
public:
  typedef enum Qt::InputMethodHint source_type;
  typedef Qt_InputMethodHint_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::InputMethodQuery>
class Qt_InputMethodQuery_Enums : public QFlags<enum Qt::InputMethodQuery> {
public:
  Qt_InputMethodQuery_Enums () : m_flags () { }
  Qt_InputMethodQuery_Enums (enum Qt::InputMethodQuery v) : m_flags (v) { }
  Qt_InputMethodQuery_Enums (const QFlags<enum Qt::InputMethodQuery> &v) : m_flags (v) { }
  QFlags<enum Qt::InputMethodQuery> flags () const { return m_flags; }
private:
  QFlags<Qt::InputMethodQuery> m_flags;
};

//  Wrapper class for enum Qt::InputMethodQuery
class Qt_InputMethodQuery_Enum : public Qt_InputMethodQuery_Enums {
public:
  Qt_InputMethodQuery_Enum () { }
  Qt_InputMethodQuery_Enum (enum Qt::InputMethodQuery v) : Qt_InputMethodQuery_Enums (v) { }
  enum Qt::InputMethodQuery value () const { return (enum Qt::InputMethodQuery) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::InputMethodQuery>
template <>
struct Converter<QFlags<enum Qt::InputMethodQuery> >
{
public:
  typedef QFlags<enum Qt::InputMethodQuery> source_type;
  typedef Qt_InputMethodQuery_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::InputMethodQuery
template <>
struct Converter<enum Qt::InputMethodQuery>
{
public:
  typedef enum Qt::InputMethodQuery source_type;
  typedef Qt_InputMethodQuery_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ItemDataRole>
class Qt_ItemDataRole_Enums : public QFlags<enum Qt::ItemDataRole> {
public:
  Qt_ItemDataRole_Enums () : m_flags () { }
  Qt_ItemDataRole_Enums (enum Qt::ItemDataRole v) : m_flags (v) { }
  Qt_ItemDataRole_Enums (const QFlags<enum Qt::ItemDataRole> &v) : m_flags (v) { }
  QFlags<enum Qt::ItemDataRole> flags () const { return m_flags; }
private:
  QFlags<Qt::ItemDataRole> m_flags;
};

//  Wrapper class for enum Qt::ItemDataRole
class Qt_ItemDataRole_Enum : public Qt_ItemDataRole_Enums {
public:
  Qt_ItemDataRole_Enum () { }
  Qt_ItemDataRole_Enum (enum Qt::ItemDataRole v) : Qt_ItemDataRole_Enums (v) { }
  enum Qt::ItemDataRole value () const { return (enum Qt::ItemDataRole) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ItemDataRole>
template <>
struct Converter<QFlags<enum Qt::ItemDataRole> >
{
public:
  typedef QFlags<enum Qt::ItemDataRole> source_type;
  typedef Qt_ItemDataRole_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ItemDataRole
template <>
struct Converter<enum Qt::ItemDataRole>
{
public:
  typedef enum Qt::ItemDataRole source_type;
  typedef Qt_ItemDataRole_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ItemFlag>
class Qt_ItemFlag_Enums : public QFlags<enum Qt::ItemFlag> {
public:
  Qt_ItemFlag_Enums () : m_flags () { }
  Qt_ItemFlag_Enums (enum Qt::ItemFlag v) : m_flags (v) { }
  Qt_ItemFlag_Enums (const QFlags<enum Qt::ItemFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::ItemFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::ItemFlag> m_flags;
};

//  Wrapper class for enum Qt::ItemFlag
class Qt_ItemFlag_Enum : public Qt_ItemFlag_Enums {
public:
  Qt_ItemFlag_Enum () { }
  Qt_ItemFlag_Enum (enum Qt::ItemFlag v) : Qt_ItemFlag_Enums (v) { }
  enum Qt::ItemFlag value () const { return (enum Qt::ItemFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ItemFlag>
template <>
struct Converter<QFlags<enum Qt::ItemFlag> >
{
public:
  typedef QFlags<enum Qt::ItemFlag> source_type;
  typedef Qt_ItemFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ItemFlag
template <>
struct Converter<enum Qt::ItemFlag>
{
public:
  typedef enum Qt::ItemFlag source_type;
  typedef Qt_ItemFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ItemSelectionMode>
class Qt_ItemSelectionMode_Enums : public QFlags<enum Qt::ItemSelectionMode> {
public:
  Qt_ItemSelectionMode_Enums () : m_flags () { }
  Qt_ItemSelectionMode_Enums (enum Qt::ItemSelectionMode v) : m_flags (v) { }
  Qt_ItemSelectionMode_Enums (const QFlags<enum Qt::ItemSelectionMode> &v) : m_flags (v) { }
  QFlags<enum Qt::ItemSelectionMode> flags () const { return m_flags; }
private:
  QFlags<Qt::ItemSelectionMode> m_flags;
};

//  Wrapper class for enum Qt::ItemSelectionMode
class Qt_ItemSelectionMode_Enum : public Qt_ItemSelectionMode_Enums {
public:
  Qt_ItemSelectionMode_Enum () { }
  Qt_ItemSelectionMode_Enum (enum Qt::ItemSelectionMode v) : Qt_ItemSelectionMode_Enums (v) { }
  enum Qt::ItemSelectionMode value () const { return (enum Qt::ItemSelectionMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ItemSelectionMode>
template <>
struct Converter<QFlags<enum Qt::ItemSelectionMode> >
{
public:
  typedef QFlags<enum Qt::ItemSelectionMode> source_type;
  typedef Qt_ItemSelectionMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ItemSelectionMode
template <>
struct Converter<enum Qt::ItemSelectionMode>
{
public:
  typedef enum Qt::ItemSelectionMode source_type;
  typedef Qt_ItemSelectionMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Key>
class Qt_Key_Enums : public QFlags<enum Qt::Key> {
public:
  Qt_Key_Enums () : m_flags () { }
  Qt_Key_Enums (enum Qt::Key v) : m_flags (v) { }
  Qt_Key_Enums (const QFlags<enum Qt::Key> &v) : m_flags (v) { }
  QFlags<enum Qt::Key> flags () const { return m_flags; }
private:
  QFlags<Qt::Key> m_flags;
};

//  Wrapper class for enum Qt::Key
class Qt_Key_Enum : public Qt_Key_Enums {
public:
  Qt_Key_Enum () { }
  Qt_Key_Enum (enum Qt::Key v) : Qt_Key_Enums (v) { }
  enum Qt::Key value () const { return (enum Qt::Key) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Key>
template <>
struct Converter<QFlags<enum Qt::Key> >
{
public:
  typedef QFlags<enum Qt::Key> source_type;
  typedef Qt_Key_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Key
template <>
struct Converter<enum Qt::Key>
{
public:
  typedef enum Qt::Key source_type;
  typedef Qt_Key_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::KeyboardModifier>
class Qt_KeyboardModifier_Enums : public QFlags<enum Qt::KeyboardModifier> {
public:
  Qt_KeyboardModifier_Enums () : m_flags () { }
  Qt_KeyboardModifier_Enums (enum Qt::KeyboardModifier v) : m_flags (v) { }
  Qt_KeyboardModifier_Enums (const QFlags<enum Qt::KeyboardModifier> &v) : m_flags (v) { }
  QFlags<enum Qt::KeyboardModifier> flags () const { return m_flags; }
private:
  QFlags<Qt::KeyboardModifier> m_flags;
};

//  Wrapper class for enum Qt::KeyboardModifier
class Qt_KeyboardModifier_Enum : public Qt_KeyboardModifier_Enums {
public:
  Qt_KeyboardModifier_Enum () { }
  Qt_KeyboardModifier_Enum (enum Qt::KeyboardModifier v) : Qt_KeyboardModifier_Enums (v) { }
  enum Qt::KeyboardModifier value () const { return (enum Qt::KeyboardModifier) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::KeyboardModifier>
template <>
struct Converter<QFlags<enum Qt::KeyboardModifier> >
{
public:
  typedef QFlags<enum Qt::KeyboardModifier> source_type;
  typedef Qt_KeyboardModifier_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::KeyboardModifier
template <>
struct Converter<enum Qt::KeyboardModifier>
{
public:
  typedef enum Qt::KeyboardModifier source_type;
  typedef Qt_KeyboardModifier_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::LayoutDirection>
class Qt_LayoutDirection_Enums : public QFlags<enum Qt::LayoutDirection> {
public:
  Qt_LayoutDirection_Enums () : m_flags () { }
  Qt_LayoutDirection_Enums (enum Qt::LayoutDirection v) : m_flags (v) { }
  Qt_LayoutDirection_Enums (const QFlags<enum Qt::LayoutDirection> &v) : m_flags (v) { }
  QFlags<enum Qt::LayoutDirection> flags () const { return m_flags; }
private:
  QFlags<Qt::LayoutDirection> m_flags;
};

//  Wrapper class for enum Qt::LayoutDirection
class Qt_LayoutDirection_Enum : public Qt_LayoutDirection_Enums {
public:
  Qt_LayoutDirection_Enum () { }
  Qt_LayoutDirection_Enum (enum Qt::LayoutDirection v) : Qt_LayoutDirection_Enums (v) { }
  enum Qt::LayoutDirection value () const { return (enum Qt::LayoutDirection) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::LayoutDirection>
template <>
struct Converter<QFlags<enum Qt::LayoutDirection> >
{
public:
  typedef QFlags<enum Qt::LayoutDirection> source_type;
  typedef Qt_LayoutDirection_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::LayoutDirection
template <>
struct Converter<enum Qt::LayoutDirection>
{
public:
  typedef enum Qt::LayoutDirection source_type;
  typedef Qt_LayoutDirection_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::MaskMode>
class Qt_MaskMode_Enums : public QFlags<enum Qt::MaskMode> {
public:
  Qt_MaskMode_Enums () : m_flags () { }
  Qt_MaskMode_Enums (enum Qt::MaskMode v) : m_flags (v) { }
  Qt_MaskMode_Enums (const QFlags<enum Qt::MaskMode> &v) : m_flags (v) { }
  QFlags<enum Qt::MaskMode> flags () const { return m_flags; }
private:
  QFlags<Qt::MaskMode> m_flags;
};

//  Wrapper class for enum Qt::MaskMode
class Qt_MaskMode_Enum : public Qt_MaskMode_Enums {
public:
  Qt_MaskMode_Enum () { }
  Qt_MaskMode_Enum (enum Qt::MaskMode v) : Qt_MaskMode_Enums (v) { }
  enum Qt::MaskMode value () const { return (enum Qt::MaskMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::MaskMode>
template <>
struct Converter<QFlags<enum Qt::MaskMode> >
{
public:
  typedef QFlags<enum Qt::MaskMode> source_type;
  typedef Qt_MaskMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::MaskMode
template <>
struct Converter<enum Qt::MaskMode>
{
public:
  typedef enum Qt::MaskMode source_type;
  typedef Qt_MaskMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::MatchFlag>
class Qt_MatchFlag_Enums : public QFlags<enum Qt::MatchFlag> {
public:
  Qt_MatchFlag_Enums () : m_flags () { }
  Qt_MatchFlag_Enums (enum Qt::MatchFlag v) : m_flags (v) { }
  Qt_MatchFlag_Enums (const QFlags<enum Qt::MatchFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::MatchFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::MatchFlag> m_flags;
};

//  Wrapper class for enum Qt::MatchFlag
class Qt_MatchFlag_Enum : public Qt_MatchFlag_Enums {
public:
  Qt_MatchFlag_Enum () { }
  Qt_MatchFlag_Enum (enum Qt::MatchFlag v) : Qt_MatchFlag_Enums (v) { }
  enum Qt::MatchFlag value () const { return (enum Qt::MatchFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::MatchFlag>
template <>
struct Converter<QFlags<enum Qt::MatchFlag> >
{
public:
  typedef QFlags<enum Qt::MatchFlag> source_type;
  typedef Qt_MatchFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::MatchFlag
template <>
struct Converter<enum Qt::MatchFlag>
{
public:
  typedef enum Qt::MatchFlag source_type;
  typedef Qt_MatchFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Modifier>
class Qt_Modifier_Enums : public QFlags<enum Qt::Modifier> {
public:
  Qt_Modifier_Enums () : m_flags () { }
  Qt_Modifier_Enums (enum Qt::Modifier v) : m_flags (v) { }
  Qt_Modifier_Enums (const QFlags<enum Qt::Modifier> &v) : m_flags (v) { }
  QFlags<enum Qt::Modifier> flags () const { return m_flags; }
private:
  QFlags<Qt::Modifier> m_flags;
};

//  Wrapper class for enum Qt::Modifier
class Qt_Modifier_Enum : public Qt_Modifier_Enums {
public:
  Qt_Modifier_Enum () { }
  Qt_Modifier_Enum (enum Qt::Modifier v) : Qt_Modifier_Enums (v) { }
  enum Qt::Modifier value () const { return (enum Qt::Modifier) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Modifier>
template <>
struct Converter<QFlags<enum Qt::Modifier> >
{
public:
  typedef QFlags<enum Qt::Modifier> source_type;
  typedef Qt_Modifier_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Modifier
template <>
struct Converter<enum Qt::Modifier>
{
public:
  typedef enum Qt::Modifier source_type;
  typedef Qt_Modifier_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::MouseButton>
class Qt_MouseButton_Enums : public QFlags<enum Qt::MouseButton> {
public:
  Qt_MouseButton_Enums () : m_flags () { }
  Qt_MouseButton_Enums (enum Qt::MouseButton v) : m_flags (v) { }
  Qt_MouseButton_Enums (const QFlags<enum Qt::MouseButton> &v) : m_flags (v) { }
  QFlags<enum Qt::MouseButton> flags () const { return m_flags; }
private:
  QFlags<Qt::MouseButton> m_flags;
};

//  Wrapper class for enum Qt::MouseButton
class Qt_MouseButton_Enum : public Qt_MouseButton_Enums {
public:
  Qt_MouseButton_Enum () { }
  Qt_MouseButton_Enum (enum Qt::MouseButton v) : Qt_MouseButton_Enums (v) { }
  enum Qt::MouseButton value () const { return (enum Qt::MouseButton) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::MouseButton>
template <>
struct Converter<QFlags<enum Qt::MouseButton> >
{
public:
  typedef QFlags<enum Qt::MouseButton> source_type;
  typedef Qt_MouseButton_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::MouseButton
template <>
struct Converter<enum Qt::MouseButton>
{
public:
  typedef enum Qt::MouseButton source_type;
  typedef Qt_MouseButton_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::NavigationMode>
class Qt_NavigationMode_Enums : public QFlags<enum Qt::NavigationMode> {
public:
  Qt_NavigationMode_Enums () : m_flags () { }
  Qt_NavigationMode_Enums (enum Qt::NavigationMode v) : m_flags (v) { }
  Qt_NavigationMode_Enums (const QFlags<enum Qt::NavigationMode> &v) : m_flags (v) { }
  QFlags<enum Qt::NavigationMode> flags () const { return m_flags; }
private:
  QFlags<Qt::NavigationMode> m_flags;
};

//  Wrapper class for enum Qt::NavigationMode
class Qt_NavigationMode_Enum : public Qt_NavigationMode_Enums {
public:
  Qt_NavigationMode_Enum () { }
  Qt_NavigationMode_Enum (enum Qt::NavigationMode v) : Qt_NavigationMode_Enums (v) { }
  enum Qt::NavigationMode value () const { return (enum Qt::NavigationMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::NavigationMode>
template <>
struct Converter<QFlags<enum Qt::NavigationMode> >
{
public:
  typedef QFlags<enum Qt::NavigationMode> source_type;
  typedef Qt_NavigationMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::NavigationMode
template <>
struct Converter<enum Qt::NavigationMode>
{
public:
  typedef enum Qt::NavigationMode source_type;
  typedef Qt_NavigationMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::Orientation>
class Qt_Orientation_Enums : public QFlags<enum Qt::Orientation> {
public:
  Qt_Orientation_Enums () : m_flags () { }
  Qt_Orientation_Enums (enum Qt::Orientation v) : m_flags (v) { }
  Qt_Orientation_Enums (const QFlags<enum Qt::Orientation> &v) : m_flags (v) { }
  QFlags<enum Qt::Orientation> flags () const { return m_flags; }
private:
  QFlags<Qt::Orientation> m_flags;
};

//  Wrapper class for enum Qt::Orientation
class Qt_Orientation_Enum : public Qt_Orientation_Enums {
public:
  Qt_Orientation_Enum () { }
  Qt_Orientation_Enum (enum Qt::Orientation v) : Qt_Orientation_Enums (v) { }
  enum Qt::Orientation value () const { return (enum Qt::Orientation) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::Orientation>
template <>
struct Converter<QFlags<enum Qt::Orientation> >
{
public:
  typedef QFlags<enum Qt::Orientation> source_type;
  typedef Qt_Orientation_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::Orientation
template <>
struct Converter<enum Qt::Orientation>
{
public:
  typedef enum Qt::Orientation source_type;
  typedef Qt_Orientation_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::PenCapStyle>
class Qt_PenCapStyle_Enums : public QFlags<enum Qt::PenCapStyle> {
public:
  Qt_PenCapStyle_Enums () : m_flags () { }
  Qt_PenCapStyle_Enums (enum Qt::PenCapStyle v) : m_flags (v) { }
  Qt_PenCapStyle_Enums (const QFlags<enum Qt::PenCapStyle> &v) : m_flags (v) { }
  QFlags<enum Qt::PenCapStyle> flags () const { return m_flags; }
private:
  QFlags<Qt::PenCapStyle> m_flags;
};

//  Wrapper class for enum Qt::PenCapStyle
class Qt_PenCapStyle_Enum : public Qt_PenCapStyle_Enums {
public:
  Qt_PenCapStyle_Enum () { }
  Qt_PenCapStyle_Enum (enum Qt::PenCapStyle v) : Qt_PenCapStyle_Enums (v) { }
  enum Qt::PenCapStyle value () const { return (enum Qt::PenCapStyle) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::PenCapStyle>
template <>
struct Converter<QFlags<enum Qt::PenCapStyle> >
{
public:
  typedef QFlags<enum Qt::PenCapStyle> source_type;
  typedef Qt_PenCapStyle_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::PenCapStyle
template <>
struct Converter<enum Qt::PenCapStyle>
{
public:
  typedef enum Qt::PenCapStyle source_type;
  typedef Qt_PenCapStyle_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::PenJoinStyle>
class Qt_PenJoinStyle_Enums : public QFlags<enum Qt::PenJoinStyle> {
public:
  Qt_PenJoinStyle_Enums () : m_flags () { }
  Qt_PenJoinStyle_Enums (enum Qt::PenJoinStyle v) : m_flags (v) { }
  Qt_PenJoinStyle_Enums (const QFlags<enum Qt::PenJoinStyle> &v) : m_flags (v) { }
  QFlags<enum Qt::PenJoinStyle> flags () const { return m_flags; }
private:
  QFlags<Qt::PenJoinStyle> m_flags;
};

//  Wrapper class for enum Qt::PenJoinStyle
class Qt_PenJoinStyle_Enum : public Qt_PenJoinStyle_Enums {
public:
  Qt_PenJoinStyle_Enum () { }
  Qt_PenJoinStyle_Enum (enum Qt::PenJoinStyle v) : Qt_PenJoinStyle_Enums (v) { }
  enum Qt::PenJoinStyle value () const { return (enum Qt::PenJoinStyle) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::PenJoinStyle>
template <>
struct Converter<QFlags<enum Qt::PenJoinStyle> >
{
public:
  typedef QFlags<enum Qt::PenJoinStyle> source_type;
  typedef Qt_PenJoinStyle_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::PenJoinStyle
template <>
struct Converter<enum Qt::PenJoinStyle>
{
public:
  typedef enum Qt::PenJoinStyle source_type;
  typedef Qt_PenJoinStyle_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::PenStyle>
class Qt_PenStyle_Enums : public QFlags<enum Qt::PenStyle> {
public:
  Qt_PenStyle_Enums () : m_flags () { }
  Qt_PenStyle_Enums (enum Qt::PenStyle v) : m_flags (v) { }
  Qt_PenStyle_Enums (const QFlags<enum Qt::PenStyle> &v) : m_flags (v) { }
  QFlags<enum Qt::PenStyle> flags () const { return m_flags; }
private:
  QFlags<Qt::PenStyle> m_flags;
};

//  Wrapper class for enum Qt::PenStyle
class Qt_PenStyle_Enum : public Qt_PenStyle_Enums {
public:
  Qt_PenStyle_Enum () { }
  Qt_PenStyle_Enum (enum Qt::PenStyle v) : Qt_PenStyle_Enums (v) { }
  enum Qt::PenStyle value () const { return (enum Qt::PenStyle) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::PenStyle>
template <>
struct Converter<QFlags<enum Qt::PenStyle> >
{
public:
  typedef QFlags<enum Qt::PenStyle> source_type;
  typedef Qt_PenStyle_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::PenStyle
template <>
struct Converter<enum Qt::PenStyle>
{
public:
  typedef enum Qt::PenStyle source_type;
  typedef Qt_PenStyle_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ScrollBarPolicy>
class Qt_ScrollBarPolicy_Enums : public QFlags<enum Qt::ScrollBarPolicy> {
public:
  Qt_ScrollBarPolicy_Enums () : m_flags () { }
  Qt_ScrollBarPolicy_Enums (enum Qt::ScrollBarPolicy v) : m_flags (v) { }
  Qt_ScrollBarPolicy_Enums (const QFlags<enum Qt::ScrollBarPolicy> &v) : m_flags (v) { }
  QFlags<enum Qt::ScrollBarPolicy> flags () const { return m_flags; }
private:
  QFlags<Qt::ScrollBarPolicy> m_flags;
};

//  Wrapper class for enum Qt::ScrollBarPolicy
class Qt_ScrollBarPolicy_Enum : public Qt_ScrollBarPolicy_Enums {
public:
  Qt_ScrollBarPolicy_Enum () { }
  Qt_ScrollBarPolicy_Enum (enum Qt::ScrollBarPolicy v) : Qt_ScrollBarPolicy_Enums (v) { }
  enum Qt::ScrollBarPolicy value () const { return (enum Qt::ScrollBarPolicy) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ScrollBarPolicy>
template <>
struct Converter<QFlags<enum Qt::ScrollBarPolicy> >
{
public:
  typedef QFlags<enum Qt::ScrollBarPolicy> source_type;
  typedef Qt_ScrollBarPolicy_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ScrollBarPolicy
template <>
struct Converter<enum Qt::ScrollBarPolicy>
{
public:
  typedef enum Qt::ScrollBarPolicy source_type;
  typedef Qt_ScrollBarPolicy_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ShortcutContext>
class Qt_ShortcutContext_Enums : public QFlags<enum Qt::ShortcutContext> {
public:
  Qt_ShortcutContext_Enums () : m_flags () { }
  Qt_ShortcutContext_Enums (enum Qt::ShortcutContext v) : m_flags (v) { }
  Qt_ShortcutContext_Enums (const QFlags<enum Qt::ShortcutContext> &v) : m_flags (v) { }
  QFlags<enum Qt::ShortcutContext> flags () const { return m_flags; }
private:
  QFlags<Qt::ShortcutContext> m_flags;
};

//  Wrapper class for enum Qt::ShortcutContext
class Qt_ShortcutContext_Enum : public Qt_ShortcutContext_Enums {
public:
  Qt_ShortcutContext_Enum () { }
  Qt_ShortcutContext_Enum (enum Qt::ShortcutContext v) : Qt_ShortcutContext_Enums (v) { }
  enum Qt::ShortcutContext value () const { return (enum Qt::ShortcutContext) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ShortcutContext>
template <>
struct Converter<QFlags<enum Qt::ShortcutContext> >
{
public:
  typedef QFlags<enum Qt::ShortcutContext> source_type;
  typedef Qt_ShortcutContext_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ShortcutContext
template <>
struct Converter<enum Qt::ShortcutContext>
{
public:
  typedef enum Qt::ShortcutContext source_type;
  typedef Qt_ShortcutContext_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::SizeHint>
class Qt_SizeHint_Enums : public QFlags<enum Qt::SizeHint> {
public:
  Qt_SizeHint_Enums () : m_flags () { }
  Qt_SizeHint_Enums (enum Qt::SizeHint v) : m_flags (v) { }
  Qt_SizeHint_Enums (const QFlags<enum Qt::SizeHint> &v) : m_flags (v) { }
  QFlags<enum Qt::SizeHint> flags () const { return m_flags; }
private:
  QFlags<Qt::SizeHint> m_flags;
};

//  Wrapper class for enum Qt::SizeHint
class Qt_SizeHint_Enum : public Qt_SizeHint_Enums {
public:
  Qt_SizeHint_Enum () { }
  Qt_SizeHint_Enum (enum Qt::SizeHint v) : Qt_SizeHint_Enums (v) { }
  enum Qt::SizeHint value () const { return (enum Qt::SizeHint) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::SizeHint>
template <>
struct Converter<QFlags<enum Qt::SizeHint> >
{
public:
  typedef QFlags<enum Qt::SizeHint> source_type;
  typedef Qt_SizeHint_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::SizeHint
template <>
struct Converter<enum Qt::SizeHint>
{
public:
  typedef enum Qt::SizeHint source_type;
  typedef Qt_SizeHint_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::SizeMode>
class Qt_SizeMode_Enums : public QFlags<enum Qt::SizeMode> {
public:
  Qt_SizeMode_Enums () : m_flags () { }
  Qt_SizeMode_Enums (enum Qt::SizeMode v) : m_flags (v) { }
  Qt_SizeMode_Enums (const QFlags<enum Qt::SizeMode> &v) : m_flags (v) { }
  QFlags<enum Qt::SizeMode> flags () const { return m_flags; }
private:
  QFlags<Qt::SizeMode> m_flags;
};

//  Wrapper class for enum Qt::SizeMode
class Qt_SizeMode_Enum : public Qt_SizeMode_Enums {
public:
  Qt_SizeMode_Enum () { }
  Qt_SizeMode_Enum (enum Qt::SizeMode v) : Qt_SizeMode_Enums (v) { }
  enum Qt::SizeMode value () const { return (enum Qt::SizeMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::SizeMode>
template <>
struct Converter<QFlags<enum Qt::SizeMode> >
{
public:
  typedef QFlags<enum Qt::SizeMode> source_type;
  typedef Qt_SizeMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::SizeMode
template <>
struct Converter<enum Qt::SizeMode>
{
public:
  typedef enum Qt::SizeMode source_type;
  typedef Qt_SizeMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::SortOrder>
class Qt_SortOrder_Enums : public QFlags<enum Qt::SortOrder> {
public:
  Qt_SortOrder_Enums () : m_flags () { }
  Qt_SortOrder_Enums (enum Qt::SortOrder v) : m_flags (v) { }
  Qt_SortOrder_Enums (const QFlags<enum Qt::SortOrder> &v) : m_flags (v) { }
  QFlags<enum Qt::SortOrder> flags () const { return m_flags; }
private:
  QFlags<Qt::SortOrder> m_flags;
};

//  Wrapper class for enum Qt::SortOrder
class Qt_SortOrder_Enum : public Qt_SortOrder_Enums {
public:
  Qt_SortOrder_Enum () { }
  Qt_SortOrder_Enum (enum Qt::SortOrder v) : Qt_SortOrder_Enums (v) { }
  enum Qt::SortOrder value () const { return (enum Qt::SortOrder) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::SortOrder>
template <>
struct Converter<QFlags<enum Qt::SortOrder> >
{
public:
  typedef QFlags<enum Qt::SortOrder> source_type;
  typedef Qt_SortOrder_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::SortOrder
template <>
struct Converter<enum Qt::SortOrder>
{
public:
  typedef enum Qt::SortOrder source_type;
  typedef Qt_SortOrder_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TextElideMode>
class Qt_TextElideMode_Enums : public QFlags<enum Qt::TextElideMode> {
public:
  Qt_TextElideMode_Enums () : m_flags () { }
  Qt_TextElideMode_Enums (enum Qt::TextElideMode v) : m_flags (v) { }
  Qt_TextElideMode_Enums (const QFlags<enum Qt::TextElideMode> &v) : m_flags (v) { }
  QFlags<enum Qt::TextElideMode> flags () const { return m_flags; }
private:
  QFlags<Qt::TextElideMode> m_flags;
};

//  Wrapper class for enum Qt::TextElideMode
class Qt_TextElideMode_Enum : public Qt_TextElideMode_Enums {
public:
  Qt_TextElideMode_Enum () { }
  Qt_TextElideMode_Enum (enum Qt::TextElideMode v) : Qt_TextElideMode_Enums (v) { }
  enum Qt::TextElideMode value () const { return (enum Qt::TextElideMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TextElideMode>
template <>
struct Converter<QFlags<enum Qt::TextElideMode> >
{
public:
  typedef QFlags<enum Qt::TextElideMode> source_type;
  typedef Qt_TextElideMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TextElideMode
template <>
struct Converter<enum Qt::TextElideMode>
{
public:
  typedef enum Qt::TextElideMode source_type;
  typedef Qt_TextElideMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TextFlag>
class Qt_TextFlag_Enums : public QFlags<enum Qt::TextFlag> {
public:
  Qt_TextFlag_Enums () : m_flags () { }
  Qt_TextFlag_Enums (enum Qt::TextFlag v) : m_flags (v) { }
  Qt_TextFlag_Enums (const QFlags<enum Qt::TextFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::TextFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::TextFlag> m_flags;
};

//  Wrapper class for enum Qt::TextFlag
class Qt_TextFlag_Enum : public Qt_TextFlag_Enums {
public:
  Qt_TextFlag_Enum () { }
  Qt_TextFlag_Enum (enum Qt::TextFlag v) : Qt_TextFlag_Enums (v) { }
  enum Qt::TextFlag value () const { return (enum Qt::TextFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TextFlag>
template <>
struct Converter<QFlags<enum Qt::TextFlag> >
{
public:
  typedef QFlags<enum Qt::TextFlag> source_type;
  typedef Qt_TextFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TextFlag
template <>
struct Converter<enum Qt::TextFlag>
{
public:
  typedef enum Qt::TextFlag source_type;
  typedef Qt_TextFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TextFormat>
class Qt_TextFormat_Enums : public QFlags<enum Qt::TextFormat> {
public:
  Qt_TextFormat_Enums () : m_flags () { }
  Qt_TextFormat_Enums (enum Qt::TextFormat v) : m_flags (v) { }
  Qt_TextFormat_Enums (const QFlags<enum Qt::TextFormat> &v) : m_flags (v) { }
  QFlags<enum Qt::TextFormat> flags () const { return m_flags; }
private:
  QFlags<Qt::TextFormat> m_flags;
};

//  Wrapper class for enum Qt::TextFormat
class Qt_TextFormat_Enum : public Qt_TextFormat_Enums {
public:
  Qt_TextFormat_Enum () { }
  Qt_TextFormat_Enum (enum Qt::TextFormat v) : Qt_TextFormat_Enums (v) { }
  enum Qt::TextFormat value () const { return (enum Qt::TextFormat) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TextFormat>
template <>
struct Converter<QFlags<enum Qt::TextFormat> >
{
public:
  typedef QFlags<enum Qt::TextFormat> source_type;
  typedef Qt_TextFormat_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TextFormat
template <>
struct Converter<enum Qt::TextFormat>
{
public:
  typedef enum Qt::TextFormat source_type;
  typedef Qt_TextFormat_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TextInteractionFlag>
class Qt_TextInteractionFlag_Enums : public QFlags<enum Qt::TextInteractionFlag> {
public:
  Qt_TextInteractionFlag_Enums () : m_flags () { }
  Qt_TextInteractionFlag_Enums (enum Qt::TextInteractionFlag v) : m_flags (v) { }
  Qt_TextInteractionFlag_Enums (const QFlags<enum Qt::TextInteractionFlag> &v) : m_flags (v) { }
  QFlags<enum Qt::TextInteractionFlag> flags () const { return m_flags; }
private:
  QFlags<Qt::TextInteractionFlag> m_flags;
};

//  Wrapper class for enum Qt::TextInteractionFlag
class Qt_TextInteractionFlag_Enum : public Qt_TextInteractionFlag_Enums {
public:
  Qt_TextInteractionFlag_Enum () { }
  Qt_TextInteractionFlag_Enum (enum Qt::TextInteractionFlag v) : Qt_TextInteractionFlag_Enums (v) { }
  enum Qt::TextInteractionFlag value () const { return (enum Qt::TextInteractionFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TextInteractionFlag>
template <>
struct Converter<QFlags<enum Qt::TextInteractionFlag> >
{
public:
  typedef QFlags<enum Qt::TextInteractionFlag> source_type;
  typedef Qt_TextInteractionFlag_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TextInteractionFlag
template <>
struct Converter<enum Qt::TextInteractionFlag>
{
public:
  typedef enum Qt::TextInteractionFlag source_type;
  typedef Qt_TextInteractionFlag_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TileRule>
class Qt_TileRule_Enums : public QFlags<enum Qt::TileRule> {
public:
  Qt_TileRule_Enums () : m_flags () { }
  Qt_TileRule_Enums (enum Qt::TileRule v) : m_flags (v) { }
  Qt_TileRule_Enums (const QFlags<enum Qt::TileRule> &v) : m_flags (v) { }
  QFlags<enum Qt::TileRule> flags () const { return m_flags; }
private:
  QFlags<Qt::TileRule> m_flags;
};

//  Wrapper class for enum Qt::TileRule
class Qt_TileRule_Enum : public Qt_TileRule_Enums {
public:
  Qt_TileRule_Enum () { }
  Qt_TileRule_Enum (enum Qt::TileRule v) : Qt_TileRule_Enums (v) { }
  enum Qt::TileRule value () const { return (enum Qt::TileRule) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TileRule>
template <>
struct Converter<QFlags<enum Qt::TileRule> >
{
public:
  typedef QFlags<enum Qt::TileRule> source_type;
  typedef Qt_TileRule_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TileRule
template <>
struct Converter<enum Qt::TileRule>
{
public:
  typedef enum Qt::TileRule source_type;
  typedef Qt_TileRule_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TimeSpec>
class Qt_TimeSpec_Enums : public QFlags<enum Qt::TimeSpec> {
public:
  Qt_TimeSpec_Enums () : m_flags () { }
  Qt_TimeSpec_Enums (enum Qt::TimeSpec v) : m_flags (v) { }
  Qt_TimeSpec_Enums (const QFlags<enum Qt::TimeSpec> &v) : m_flags (v) { }
  QFlags<enum Qt::TimeSpec> flags () const { return m_flags; }
private:
  QFlags<Qt::TimeSpec> m_flags;
};

//  Wrapper class for enum Qt::TimeSpec
class Qt_TimeSpec_Enum : public Qt_TimeSpec_Enums {
public:
  Qt_TimeSpec_Enum () { }
  Qt_TimeSpec_Enum (enum Qt::TimeSpec v) : Qt_TimeSpec_Enums (v) { }
  enum Qt::TimeSpec value () const { return (enum Qt::TimeSpec) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TimeSpec>
template <>
struct Converter<QFlags<enum Qt::TimeSpec> >
{
public:
  typedef QFlags<enum Qt::TimeSpec> source_type;
  typedef Qt_TimeSpec_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TimeSpec
template <>
struct Converter<enum Qt::TimeSpec>
{
public:
  typedef enum Qt::TimeSpec source_type;
  typedef Qt_TimeSpec_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ToolBarArea>
class Qt_ToolBarArea_Enums : public QFlags<enum Qt::ToolBarArea> {
public:
  Qt_ToolBarArea_Enums () : m_flags () { }
  Qt_ToolBarArea_Enums (enum Qt::ToolBarArea v) : m_flags (v) { }
  Qt_ToolBarArea_Enums (const QFlags<enum Qt::ToolBarArea> &v) : m_flags (v) { }
  QFlags<enum Qt::ToolBarArea> flags () const { return m_flags; }
private:
  QFlags<Qt::ToolBarArea> m_flags;
};

//  Wrapper class for enum Qt::ToolBarArea
class Qt_ToolBarArea_Enum : public Qt_ToolBarArea_Enums {
public:
  Qt_ToolBarArea_Enum () { }
  Qt_ToolBarArea_Enum (enum Qt::ToolBarArea v) : Qt_ToolBarArea_Enums (v) { }
  enum Qt::ToolBarArea value () const { return (enum Qt::ToolBarArea) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ToolBarArea>
template <>
struct Converter<QFlags<enum Qt::ToolBarArea> >
{
public:
  typedef QFlags<enum Qt::ToolBarArea> source_type;
  typedef Qt_ToolBarArea_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ToolBarArea
template <>
struct Converter<enum Qt::ToolBarArea>
{
public:
  typedef enum Qt::ToolBarArea source_type;
  typedef Qt_ToolBarArea_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ToolBarAreaSizes>
class Qt_ToolBarAreaSizes_Enums : public QFlags<enum Qt::ToolBarAreaSizes> {
public:
  Qt_ToolBarAreaSizes_Enums () : m_flags () { }
  Qt_ToolBarAreaSizes_Enums (enum Qt::ToolBarAreaSizes v) : m_flags (v) { }
  Qt_ToolBarAreaSizes_Enums (const QFlags<enum Qt::ToolBarAreaSizes> &v) : m_flags (v) { }
  QFlags<enum Qt::ToolBarAreaSizes> flags () const { return m_flags; }
private:
  QFlags<Qt::ToolBarAreaSizes> m_flags;
};

//  Wrapper class for enum Qt::ToolBarAreaSizes
class Qt_ToolBarAreaSizes_Enum : public Qt_ToolBarAreaSizes_Enums {
public:
  Qt_ToolBarAreaSizes_Enum () { }
  Qt_ToolBarAreaSizes_Enum (enum Qt::ToolBarAreaSizes v) : Qt_ToolBarAreaSizes_Enums (v) { }
  enum Qt::ToolBarAreaSizes value () const { return (enum Qt::ToolBarAreaSizes) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ToolBarAreaSizes>
template <>
struct Converter<QFlags<enum Qt::ToolBarAreaSizes> >
{
public:
  typedef QFlags<enum Qt::ToolBarAreaSizes> source_type;
  typedef Qt_ToolBarAreaSizes_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ToolBarAreaSizes
template <>
struct Converter<enum Qt::ToolBarAreaSizes>
{
public:
  typedef enum Qt::ToolBarAreaSizes source_type;
  typedef Qt_ToolBarAreaSizes_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::ToolButtonStyle>
class Qt_ToolButtonStyle_Enums : public QFlags<enum Qt::ToolButtonStyle> {
public:
  Qt_ToolButtonStyle_Enums () : m_flags () { }
  Qt_ToolButtonStyle_Enums (enum Qt::ToolButtonStyle v) : m_flags (v) { }
  Qt_ToolButtonStyle_Enums (const QFlags<enum Qt::ToolButtonStyle> &v) : m_flags (v) { }
  QFlags<enum Qt::ToolButtonStyle> flags () const { return m_flags; }
private:
  QFlags<Qt::ToolButtonStyle> m_flags;
};

//  Wrapper class for enum Qt::ToolButtonStyle
class Qt_ToolButtonStyle_Enum : public Qt_ToolButtonStyle_Enums {
public:
  Qt_ToolButtonStyle_Enum () { }
  Qt_ToolButtonStyle_Enum (enum Qt::ToolButtonStyle v) : Qt_ToolButtonStyle_Enums (v) { }
  enum Qt::ToolButtonStyle value () const { return (enum Qt::ToolButtonStyle) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::ToolButtonStyle>
template <>
struct Converter<QFlags<enum Qt::ToolButtonStyle> >
{
public:
  typedef QFlags<enum Qt::ToolButtonStyle> source_type;
  typedef Qt_ToolButtonStyle_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::ToolButtonStyle
template <>
struct Converter<enum Qt::ToolButtonStyle>
{
public:
  typedef enum Qt::ToolButtonStyle source_type;
  typedef Qt_ToolButtonStyle_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TouchPointState>
class Qt_TouchPointState_Enums : public QFlags<enum Qt::TouchPointState> {
public:
  Qt_TouchPointState_Enums () : m_flags () { }
  Qt_TouchPointState_Enums (enum Qt::TouchPointState v) : m_flags (v) { }
  Qt_TouchPointState_Enums (const QFlags<enum Qt::TouchPointState> &v) : m_flags (v) { }
  QFlags<enum Qt::TouchPointState> flags () const { return m_flags; }
private:
  QFlags<Qt::TouchPointState> m_flags;
};

//  Wrapper class for enum Qt::TouchPointState
class Qt_TouchPointState_Enum : public Qt_TouchPointState_Enums {
public:
  Qt_TouchPointState_Enum () { }
  Qt_TouchPointState_Enum (enum Qt::TouchPointState v) : Qt_TouchPointState_Enums (v) { }
  enum Qt::TouchPointState value () const { return (enum Qt::TouchPointState) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TouchPointState>
template <>
struct Converter<QFlags<enum Qt::TouchPointState> >
{
public:
  typedef QFlags<enum Qt::TouchPointState> source_type;
  typedef Qt_TouchPointState_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TouchPointState
template <>
struct Converter<enum Qt::TouchPointState>
{
public:
  typedef enum Qt::TouchPointState source_type;
  typedef Qt_TouchPointState_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::TransformationMode>
class Qt_TransformationMode_Enums : public QFlags<enum Qt::TransformationMode> {
public:
  Qt_TransformationMode_Enums () : m_flags () { }
  Qt_TransformationMode_Enums (enum Qt::TransformationMode v) : m_flags (v) { }
  Qt_TransformationMode_Enums (const QFlags<enum Qt::TransformationMode> &v) : m_flags (v) { }
  QFlags<enum Qt::TransformationMode> flags () const { return m_flags; }
private:
  QFlags<Qt::TransformationMode> m_flags;
};

//  Wrapper class for enum Qt::TransformationMode
class Qt_TransformationMode_Enum : public Qt_TransformationMode_Enums {
public:
  Qt_TransformationMode_Enum () { }
  Qt_TransformationMode_Enum (enum Qt::TransformationMode v) : Qt_TransformationMode_Enums (v) { }
  enum Qt::TransformationMode value () const { return (enum Qt::TransformationMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::TransformationMode>
template <>
struct Converter<QFlags<enum Qt::TransformationMode> >
{
public:
  typedef QFlags<enum Qt::TransformationMode> source_type;
  typedef Qt_TransformationMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::TransformationMode
template <>
struct Converter<enum Qt::TransformationMode>
{
public:
  typedef enum Qt::TransformationMode source_type;
  typedef Qt_TransformationMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::UIEffect>
class Qt_UIEffect_Enums : public QFlags<enum Qt::UIEffect> {
public:
  Qt_UIEffect_Enums () : m_flags () { }
  Qt_UIEffect_Enums (enum Qt::UIEffect v) : m_flags (v) { }
  Qt_UIEffect_Enums (const QFlags<enum Qt::UIEffect> &v) : m_flags (v) { }
  QFlags<enum Qt::UIEffect> flags () const { return m_flags; }
private:
  QFlags<Qt::UIEffect> m_flags;
};

//  Wrapper class for enum Qt::UIEffect
class Qt_UIEffect_Enum : public Qt_UIEffect_Enums {
public:
  Qt_UIEffect_Enum () { }
  Qt_UIEffect_Enum (enum Qt::UIEffect v) : Qt_UIEffect_Enums (v) { }
  enum Qt::UIEffect value () const { return (enum Qt::UIEffect) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::UIEffect>
template <>
struct Converter<QFlags<enum Qt::UIEffect> >
{
public:
  typedef QFlags<enum Qt::UIEffect> source_type;
  typedef Qt_UIEffect_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::UIEffect
template <>
struct Converter<enum Qt::UIEffect>
{
public:
  typedef enum Qt::UIEffect source_type;
  typedef Qt_UIEffect_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WhiteSpaceMode>
class Qt_WhiteSpaceMode_Enums : public QFlags<enum Qt::WhiteSpaceMode> {
public:
  Qt_WhiteSpaceMode_Enums () : m_flags () { }
  Qt_WhiteSpaceMode_Enums (enum Qt::WhiteSpaceMode v) : m_flags (v) { }
  Qt_WhiteSpaceMode_Enums (const QFlags<enum Qt::WhiteSpaceMode> &v) : m_flags (v) { }
  QFlags<enum Qt::WhiteSpaceMode> flags () const { return m_flags; }
private:
  QFlags<Qt::WhiteSpaceMode> m_flags;
};

//  Wrapper class for enum Qt::WhiteSpaceMode
class Qt_WhiteSpaceMode_Enum : public Qt_WhiteSpaceMode_Enums {
public:
  Qt_WhiteSpaceMode_Enum () { }
  Qt_WhiteSpaceMode_Enum (enum Qt::WhiteSpaceMode v) : Qt_WhiteSpaceMode_Enums (v) { }
  enum Qt::WhiteSpaceMode value () const { return (enum Qt::WhiteSpaceMode) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WhiteSpaceMode>
template <>
struct Converter<QFlags<enum Qt::WhiteSpaceMode> >
{
public:
  typedef QFlags<enum Qt::WhiteSpaceMode> source_type;
  typedef Qt_WhiteSpaceMode_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WhiteSpaceMode
template <>
struct Converter<enum Qt::WhiteSpaceMode>
{
public:
  typedef enum Qt::WhiteSpaceMode source_type;
  typedef Qt_WhiteSpaceMode_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WidgetAttribute>
class Qt_WidgetAttribute_Enums : public QFlags<enum Qt::WidgetAttribute> {
public:
  Qt_WidgetAttribute_Enums () : m_flags () { }
  Qt_WidgetAttribute_Enums (enum Qt::WidgetAttribute v) : m_flags (v) { }
  Qt_WidgetAttribute_Enums (const QFlags<enum Qt::WidgetAttribute> &v) : m_flags (v) { }
  QFlags<enum Qt::WidgetAttribute> flags () const { return m_flags; }
private:
  QFlags<Qt::WidgetAttribute> m_flags;
};

//  Wrapper class for enum Qt::WidgetAttribute
class Qt_WidgetAttribute_Enum : public Qt_WidgetAttribute_Enums {
public:
  Qt_WidgetAttribute_Enum () { }
  Qt_WidgetAttribute_Enum (enum Qt::WidgetAttribute v) : Qt_WidgetAttribute_Enums (v) { }
  enum Qt::WidgetAttribute value () const { return (enum Qt::WidgetAttribute) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WidgetAttribute>
template <>
struct Converter<QFlags<enum Qt::WidgetAttribute> >
{
public:
  typedef QFlags<enum Qt::WidgetAttribute> source_type;
  typedef Qt_WidgetAttribute_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WidgetAttribute
template <>
struct Converter<enum Qt::WidgetAttribute>
{
public:
  typedef enum Qt::WidgetAttribute source_type;
  typedef Qt_WidgetAttribute_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WindowFrameSection>
class Qt_WindowFrameSection_Enums : public QFlags<enum Qt::WindowFrameSection> {
public:
  Qt_WindowFrameSection_Enums () : m_flags () { }
  Qt_WindowFrameSection_Enums (enum Qt::WindowFrameSection v) : m_flags (v) { }
  Qt_WindowFrameSection_Enums (const QFlags<enum Qt::WindowFrameSection> &v) : m_flags (v) { }
  QFlags<enum Qt::WindowFrameSection> flags () const { return m_flags; }
private:
  QFlags<Qt::WindowFrameSection> m_flags;
};

//  Wrapper class for enum Qt::WindowFrameSection
class Qt_WindowFrameSection_Enum : public Qt_WindowFrameSection_Enums {
public:
  Qt_WindowFrameSection_Enum () { }
  Qt_WindowFrameSection_Enum (enum Qt::WindowFrameSection v) : Qt_WindowFrameSection_Enums (v) { }
  enum Qt::WindowFrameSection value () const { return (enum Qt::WindowFrameSection) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WindowFrameSection>
template <>
struct Converter<QFlags<enum Qt::WindowFrameSection> >
{
public:
  typedef QFlags<enum Qt::WindowFrameSection> source_type;
  typedef Qt_WindowFrameSection_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WindowFrameSection
template <>
struct Converter<enum Qt::WindowFrameSection>
{
public:
  typedef enum Qt::WindowFrameSection source_type;
  typedef Qt_WindowFrameSection_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WindowModality>
class Qt_WindowModality_Enums : public QFlags<enum Qt::WindowModality> {
public:
  Qt_WindowModality_Enums () : m_flags () { }
  Qt_WindowModality_Enums (enum Qt::WindowModality v) : m_flags (v) { }
  Qt_WindowModality_Enums (const QFlags<enum Qt::WindowModality> &v) : m_flags (v) { }
  QFlags<enum Qt::WindowModality> flags () const { return m_flags; }
private:
  QFlags<Qt::WindowModality> m_flags;
};

//  Wrapper class for enum Qt::WindowModality
class Qt_WindowModality_Enum : public Qt_WindowModality_Enums {
public:
  Qt_WindowModality_Enum () { }
  Qt_WindowModality_Enum (enum Qt::WindowModality v) : Qt_WindowModality_Enums (v) { }
  enum Qt::WindowModality value () const { return (enum Qt::WindowModality) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WindowModality>
template <>
struct Converter<QFlags<enum Qt::WindowModality> >
{
public:
  typedef QFlags<enum Qt::WindowModality> source_type;
  typedef Qt_WindowModality_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WindowModality
template <>
struct Converter<enum Qt::WindowModality>
{
public:
  typedef enum Qt::WindowModality source_type;
  typedef Qt_WindowModality_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WindowState>
class Qt_WindowState_Enums : public QFlags<enum Qt::WindowState> {
public:
  Qt_WindowState_Enums () : m_flags () { }
  Qt_WindowState_Enums (enum Qt::WindowState v) : m_flags (v) { }
  Qt_WindowState_Enums (const QFlags<enum Qt::WindowState> &v) : m_flags (v) { }
  QFlags<enum Qt::WindowState> flags () const { return m_flags; }
private:
  QFlags<Qt::WindowState> m_flags;
};

//  Wrapper class for enum Qt::WindowState
class Qt_WindowState_Enum : public Qt_WindowState_Enums {
public:
  Qt_WindowState_Enum () { }
  Qt_WindowState_Enum (enum Qt::WindowState v) : Qt_WindowState_Enums (v) { }
  enum Qt::WindowState value () const { return (enum Qt::WindowState) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WindowState>
template <>
struct Converter<QFlags<enum Qt::WindowState> >
{
public:
  typedef QFlags<enum Qt::WindowState> source_type;
  typedef Qt_WindowState_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WindowState
template <>
struct Converter<enum Qt::WindowState>
{
public:
  typedef enum Qt::WindowState source_type;
  typedef Qt_WindowState_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Wrapper class for QFlags<enum Qt::WindowType>
class Qt_WindowType_Enums : public QFlags<enum Qt::WindowType> {
public:
  Qt_WindowType_Enums () : m_flags () { }
  Qt_WindowType_Enums (enum Qt::WindowType v) : m_flags (v) { }
  Qt_WindowType_Enums (const QFlags<enum Qt::WindowType> &v) : m_flags (v) { }
  QFlags<enum Qt::WindowType> flags () const { return m_flags; }
private:
  QFlags<Qt::WindowType> m_flags;
};

//  Wrapper class for enum Qt::WindowType
class Qt_WindowType_Enum : public Qt_WindowType_Enums {
public:
  Qt_WindowType_Enum () { }
  Qt_WindowType_Enum (enum Qt::WindowType v) : Qt_WindowType_Enums (v) { }
  enum Qt::WindowType value () const { return (enum Qt::WindowType) flags ().operator int (); }
};

//  Converter for QFlags<enum Qt::WindowType>
template <>
struct Converter<QFlags<enum Qt::WindowType> >
{
public:
  typedef QFlags<enum Qt::WindowType> source_type;
  typedef Qt_WindowType_Enums target_type;
  static source_type toq (const target_type &c) { return c.flags (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

//  Converter for enum Qt::WindowType
template <>
struct Converter<enum Qt::WindowType>
{
public:
  typedef enum Qt::WindowType source_type;
  typedef Qt_WindowType_Enum target_type;
  static source_type toq (const target_type &c) { return c.value (); }
  static target_type toc (const source_type &qc) { return target_type (qc); }
};

}

#endif
