
/*

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

#ifndef _HDR_gsiDeclQApplication_Enums
#define _HDR_gsiDeclQApplication_Enums

#include <QtCore/QFlags>

namespace qt_gsi
{

//  Wrapper class for QFlags<enum QApplication::Type>
class QApplication_Type_Enums : public QFlags<enum QApplication::Type> {
public:
  QApplication_Type_Enums () : m_flags () { }
  QApplication_Type_Enums (enum QApplication::Type v) : m_flags (v) { }
  QApplication_Type_Enums (const QFlags<enum QApplication::Type> &v) : m_flags (v) { }
  QFlags<enum QApplication::Type> flags () const { return m_flags; }
private:
  QFlags<QApplication::Type> m_flags;
};

//  Wrapper class for enum QApplication::Type
class QApplication_Type_Enum : public QApplication_Type_Enums {
public:
  QApplication_Type_Enum () { }
  QApplication_Type_Enum (enum QApplication::Type v) : QApplication_Type_Enums (v) { }
  enum QApplication::Type value () const { return (enum QApplication::Type) flags ().operator int (); }
};

//  Converter for QFlags<enum QApplication::Type>
template <>
struct Converter<QFlags<enum QApplication::Type> >
{
public:
  typedef QFlags<enum QApplication::Type> source_type;
  typedef QApplication_Type_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 QApplication::Type
template <>
struct Converter<enum QApplication::Type>
{
public:
  typedef enum QApplication::Type source_type;
  typedef QApplication_Type_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 QCoreApplication::Encoding>
class QCoreApplication_Encoding_Enums : public QFlags<enum QCoreApplication::Encoding> {
public:
  QCoreApplication_Encoding_Enums () : m_flags () { }
  QCoreApplication_Encoding_Enums (enum QCoreApplication::Encoding v) : m_flags (v) { }
  QCoreApplication_Encoding_Enums (const QFlags<enum QCoreApplication::Encoding> &v) : m_flags (v) { }
  QFlags<enum QCoreApplication::Encoding> flags () const { return m_flags; }
private:
  QFlags<QCoreApplication::Encoding> m_flags;
};

//  Wrapper class for enum QCoreApplication::Encoding
class QCoreApplication_Encoding_Enum : public QCoreApplication_Encoding_Enums {
public:
  QCoreApplication_Encoding_Enum () { }
  QCoreApplication_Encoding_Enum (enum QCoreApplication::Encoding v) : QCoreApplication_Encoding_Enums (v) { }
  enum QCoreApplication::Encoding value () const { return (enum QCoreApplication::Encoding) flags ().operator int (); }
};

//  Converter for QFlags<enum QCoreApplication::Encoding>
template <>
struct Converter<QFlags<enum QCoreApplication::Encoding> >
{
public:
  typedef QFlags<enum QCoreApplication::Encoding> source_type;
  typedef QCoreApplication_Encoding_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 QCoreApplication::Encoding
template <>
struct Converter<enum QCoreApplication::Encoding>
{
public:
  typedef enum QCoreApplication::Encoding source_type;
  typedef QCoreApplication_Encoding_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 QEventLoop::ProcessEventsFlag>
class QEventLoop_ProcessEventsFlag_Enums : public QFlags<enum QEventLoop::ProcessEventsFlag> {
public:
  QEventLoop_ProcessEventsFlag_Enums () : m_flags () { }
  QEventLoop_ProcessEventsFlag_Enums (enum QEventLoop::ProcessEventsFlag v) : m_flags (v) { }
  QEventLoop_ProcessEventsFlag_Enums (const QFlags<enum QEventLoop::ProcessEventsFlag> &v) : m_flags (v) { }
  QFlags<enum QEventLoop::ProcessEventsFlag> flags () const { return m_flags; }
private:
  QFlags<QEventLoop::ProcessEventsFlag> m_flags;
};

//  Wrapper class for enum QEventLoop::ProcessEventsFlag
class QEventLoop_ProcessEventsFlag_Enum : public QEventLoop_ProcessEventsFlag_Enums {
public:
  QEventLoop_ProcessEventsFlag_Enum () { }
  QEventLoop_ProcessEventsFlag_Enum (enum QEventLoop::ProcessEventsFlag v) : QEventLoop_ProcessEventsFlag_Enums (v) { }
  enum QEventLoop::ProcessEventsFlag value () const { return (enum QEventLoop::ProcessEventsFlag) flags ().operator int (); }
};

//  Converter for QFlags<enum QEventLoop::ProcessEventsFlag>
template <>
struct Converter<QFlags<enum QEventLoop::ProcessEventsFlag> >
{
public:
  typedef QFlags<enum QEventLoop::ProcessEventsFlag> source_type;
  typedef QEventLoop_ProcessEventsFlag_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 QEventLoop::ProcessEventsFlag
template <>
struct Converter<enum QEventLoop::ProcessEventsFlag>
{
public:
  typedef enum QEventLoop::ProcessEventsFlag source_type;
  typedef QEventLoop_ProcessEventsFlag_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::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::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::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::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); }
};

}

#endif
