QVariant.hs

{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Core.QVariant (
  QVariantValue (..),
  QVariantConstPtr (..),
  canConvert,
  isNull,
  isValid,
  toBool,
  toByteArray,
  toChar,
  toDouble,
  toFloat,
  toInt,
  toLongLong,
  toPoint,
  toPointF,
  toRect,
  toRectF,
  toSize,
  toSizeF,
  toList,
  toStringList,
  toString,
  toUInt,
  toULongLong,
  getType,
  userType,
  eQ,
  nE,
  lT,
  lE,
  gT,
  gE,
  QVariantPtr (..),
  clear,
  convert,
  setToBool,
  setToChar,
  setToDouble,
  setToFloat,
  setToInt,
  setToList,
  setToLongLong,
  setToPoint,
  setToPointF,
  setToRect,
  setToRectF,
  setToSize,
  setToSizeF,
  setToStringList,
  setToString,
  setToUInt,
  setToULongLong,
  swap,
  aSSIGN,
  QVariantConst (..),
  castQVariantToConst,
  QVariant (..),
  castQVariantToNonconst,
  new,
  newWithBool,
  newWithByteArray,
  newWithChar,
  newWithDouble,
  newWithFloat,
  newWithInt,
  newWithList,
  newWithLongLong,
  newWithPointF,
  newWithPoint,
  newWithRectF,
  newWithRect,
  newWithSizeF,
  newWithSize,
  newWithString,
  newWithStringList,
  newWithType,
  newWithUInt,
  newWithULongLong,
  newCopy,
  QVariantSuper (..),
  QVariantSuperConst (..),
  QVariantType (..),
  ) where

import Control.Monad ((>=>))
import qualified Data.ByteString as QtahDBS
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HPoint as HPoint
import qualified Graphics.UI.Qtah.Core.HPointF as HPointF
import qualified Graphics.UI.Qtah.Core.HRect as HRect
import qualified Graphics.UI.Qtah.Core.HSize as HSize
import qualified Graphics.UI.Qtah.Generated.Core.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QChar as M16
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QList.QVariant as M208
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QPointF as M116
import qualified Graphics.UI.Qtah.Generated.Core.QRect as M122
import qualified Graphics.UI.Qtah.Generated.Core.QRectF as M124
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Core.QSizeF as M136
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QVariant_new" new' ::  HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithBool" newWithBool' ::  HoppyFC.CBool -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithByteArray" newWithByteArray' ::  HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithChar" newWithChar' ::  HoppyF.Ptr M16.QCharConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithDouble" newWithDouble' ::  HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithFloat" newWithFloat' ::  HoppyFC.CFloat -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithInt" newWithInt' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithList" newWithList' ::  HoppyF.Ptr M208.QListQVariantConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithLongLong" newWithLongLong' ::  HoppyFC.CLLong -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithPointF" newWithPointF' ::  HoppyF.Ptr M116.QPointFConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithPoint" newWithPoint' ::  HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithRectF" newWithRectF' ::  HoppyF.Ptr M124.QRectFConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithRect" newWithRect' ::  HoppyF.Ptr M122.QRectConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithSizeF" newWithSizeF' ::  HoppyF.Ptr M136.QSizeFConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithSize" newWithSize' ::  HoppyF.Ptr M134.QSizeConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithString" newWithString' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithStringList" newWithStringList' ::  HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithType" newWithType' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithUInt" newWithUInt' ::  HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newWithULongLong" newWithULongLong' ::  HoppyFC.CULLong -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_newCopy" newCopy' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "genpop__QVariant_canConvert" canConvert' ::  HoppyF.Ptr QVariantConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_clear" clear' ::  HoppyF.Ptr QVariant -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_convert" convert' ::  HoppyF.Ptr QVariant -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_isNull" isNull' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_isValid" isValid' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_setToBool" setToBool' ::  HoppyF.Ptr QVariant -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToChar" setToChar' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M16.QCharConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToDouble" setToDouble' ::  HoppyF.Ptr QVariant -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToFloat" setToFloat' ::  HoppyF.Ptr QVariant -> HoppyFC.CFloat -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToInt" setToInt' ::  HoppyF.Ptr QVariant -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToList" setToList' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M208.QListQVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToLongLong" setToLongLong' ::  HoppyF.Ptr QVariant -> HoppyFC.CLLong -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToPoint" setToPoint' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToPointF" setToPointF' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToRect" setToRect' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToRectF" setToRectF' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToSize" setToSize' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToSizeF" setToSizeF' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M136.QSizeFConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToStringList" setToStringList' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToString" setToString' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToUInt" setToUInt' ::  HoppyF.Ptr QVariant -> HoppyFC.CUInt -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_setToULongLong" setToULongLong' ::  HoppyF.Ptr QVariant -> HoppyFC.CULLong -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_swap" swap' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr QVariant -> HoppyP.IO ()
foreign import ccall "genpop__QVariant_toBool" toBool' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_toByteArray" toByteArray' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QVariant_toChar" toChar' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M16.QCharConst)
foreign import ccall "genpop__QVariant_toDouble" toDouble' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QVariant_toFloat" toFloat' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CFloat
foreign import ccall "genpop__QVariant_toInt" toInt' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVariant_toLongLong" toLongLong' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CLLong
foreign import ccall "genpop__QVariant_toPoint" toPoint' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QVariant_toPointF" toPointF' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QVariant_toRect" toRect' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QVariant_toRectF" toRectF' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QVariant_toSize" toSize' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QVariant_toSizeF" toSizeF' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M136.QSizeFConst)
foreign import ccall "genpop__QVariant_toList" toList' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M208.QListQVariantConst)
foreign import ccall "genpop__QVariant_toStringList" toStringList' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QVariant_toString" toString' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QVariant_toUInt" toUInt' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CUInt
foreign import ccall "genpop__QVariant_toULongLong" toULongLong' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CULLong
foreign import ccall "genpop__QVariant_getType" getType' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVariant_userType" userType' ::  HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QVariant_EQ" eQ' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_NE" nE' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_LT" lT' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_LE" lE' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_GT" gT' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_GE" gE' ::  HoppyF.Ptr QVariantConst -> HoppyF.Ptr QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QVariant_ASSIGN" aSSIGN' ::  HoppyF.Ptr QVariant -> HoppyF.Ptr QVariantConst -> HoppyP.IO (HoppyF.Ptr QVariant)
foreign import ccall "gendel__QVariant" delete'QVariant :: HoppyF.Ptr QVariantConst -> HoppyP.IO ()
foreign import ccall "&gendel__QVariant" deletePtr'QVariant :: HoppyF.FunPtr (HoppyF.Ptr QVariantConst -> HoppyP.IO ())

class QVariantValue a where
  withQVariantPtr :: a -> (QVariantConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QVariantConstPtr a => QVariantValue a where
  withQVariantPtr = HoppyP.flip ($) . toQVariantConst

class (HoppyFHR.CppPtr this) => QVariantConstPtr this where
  toQVariantConst :: this -> QVariantConst

canConvert :: (QVariantValue this) => (this) {- ^ this -} -> (QVariantType) -> (HoppyP.IO HoppyP.Bool)
canConvert arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (canConvert' arg'1' arg'2')

isNull :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isNull arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isNull' arg'1')

isValid :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
isValid arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isValid' arg'1')

toBool :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
toBool arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (toBool' arg'1')

toByteArray :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
toByteArray arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (toByteArray' arg'1')

toChar :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.Char)
toChar arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M16.QCharConst) =<<
  (toChar' arg'1')

toDouble :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
toDouble arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toDouble' arg'1')

toFloat :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Float)
toFloat arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (toFloat' arg'1')

toInt :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
toInt arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (toInt' arg'1')

toLongLong :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CLLong)
toLongLong arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toLongLong' arg'1')

toPoint :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HPoint.HPoint)
toPoint arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (toPoint' arg'1')

toPointF :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
toPointF arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (toPointF' arg'1')

toRect :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HRect.HRect)
toRect arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M122.QRectConst) =<<
  (toRect' arg'1')

toRectF :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO M124.QRectF)
toRectF arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M124.QRectFConst) =<<
  (toRectF' arg'1')

toSize :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
toSize arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (toSize' arg'1')

toSizeF :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO M136.QSizeF)
toSizeF arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M136.QSizeFConst) =<<
  (toSizeF' arg'1')

toList :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO [QVariant])
toList arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M208.QListQVariantConst) =<<
  (toList' arg'1')

toStringList :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
toStringList arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (toStringList' arg'1')

toString :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toString arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toString' arg'1')

toUInt :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CUInt)
toUInt arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toUInt' arg'1')

toULongLong :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyFC.CULLong)
toULongLong arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (toULongLong' arg'1')

getType :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO QVariantType)
getType arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (getType' arg'1')

userType :: (QVariantValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
userType arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (userType' arg'1')

eQ :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

lT :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lT arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lT' arg'1' arg'2')

lE :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
lE arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (lE' arg'1' arg'2')

gT :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gT arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gT' arg'1' arg'2')

gE :: (QVariantValue this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
gE arg'1 arg'2 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (gE' arg'1' arg'2')

class (QVariantConstPtr this) => QVariantPtr this where
  toQVariant :: this -> QVariant

clear :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (clear' arg'1')

convert :: (QVariantPtr this) => (this) {- ^ this -} -> (QVariantType) -> (HoppyP.IO HoppyP.Bool)
convert arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (convert' arg'1' arg'2')

setToBool :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setToBool arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setToBool' arg'1' arg'2')

setToChar :: (QVariantPtr this, M16.QCharValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToChar arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M16.withQCharPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToChar' arg'1' arg'2')

setToDouble :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setToDouble arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setToDouble' arg'1' arg'2')

setToFloat :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Float) -> (HoppyP.IO ())
setToFloat arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setToFloat' arg'1' arg'2')

setToInt :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setToInt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setToInt' arg'1' arg'2')

setToList :: (QVariantPtr this, M208.QListQVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToList arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M208.withQListQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToList' arg'1' arg'2')

setToLongLong :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyFC.CLLong) -> (HoppyP.IO ())
setToLongLong arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setToLongLong' arg'1' arg'2')

setToPoint :: (QVariantPtr this, M114.QPointValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToPoint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToPoint' arg'1' arg'2')

setToPointF :: (QVariantPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToPointF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToPointF' arg'1' arg'2')

setToRect :: (QVariantPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToRect' arg'1' arg'2')

setToRectF :: (QVariantPtr this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToRectF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToRectF' arg'1' arg'2')

setToSize :: (QVariantPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToSize' arg'1' arg'2')

setToSizeF :: (QVariantPtr this, M136.QSizeFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToSizeF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M136.withQSizeFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToSizeF' arg'1' arg'2')

setToStringList :: (QVariantPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToStringList arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToStringList' arg'1' arg'2')

setToString :: (QVariantPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToString arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToString' arg'1' arg'2')

setToUInt :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyFC.CUInt) -> (HoppyP.IO ())
setToUInt arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setToUInt' arg'1' arg'2')

setToULongLong :: (QVariantPtr this) => (this) {- ^ this -} -> (HoppyFC.CULLong) -> (HoppyP.IO ())
setToULongLong arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (setToULongLong' arg'1' arg'2')

swap :: (QVariantPtr this, QVariantPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQVariant arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QVariantPtr this, QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QVariant)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQVariant arg'1) $ \arg'1' ->
  withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QVariant
  (aSSIGN' arg'1' arg'2')

data QVariantConst =
    QVariantConst (HoppyF.Ptr QVariantConst)
  | QVariantConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVariantConst)
  deriving (HoppyP.Show)

instance HoppyP.Eq QVariantConst where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QVariantConst where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQVariantToConst :: QVariant -> QVariantConst
castQVariantToConst (QVariant ptr') = QVariantConst $ HoppyF.castPtr ptr'
castQVariantToConst (QVariantGc fptr' ptr') = QVariantConstGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QVariantConst where
  nullptr = QVariantConst HoppyF.nullPtr
  
  withCppPtr (QVariantConst ptr') f' = f' ptr'
  withCppPtr (QVariantConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QVariantConst ptr') = ptr'
  toPtr (QVariantConstGc _ ptr') = ptr'
  
  touchCppPtr (QVariantConst _) = HoppyP.return ()
  touchCppPtr (QVariantConstGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QVariantConst where
  delete (QVariantConst ptr') = delete'QVariant ptr'
  delete (QVariantConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QVariantConst", " object."]
  
  toGc this'@(QVariantConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QVariantConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QVariant :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QVariantConstGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QVariantConst QVariant where copy = newCopy

instance QVariantConstPtr QVariantConst where
  toQVariantConst = HoppyP.id

data QVariant =
    QVariant (HoppyF.Ptr QVariant)
  | QVariantGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QVariant)
  deriving (HoppyP.Show)

instance HoppyP.Eq QVariant where
  x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y

instance HoppyP.Ord QVariant where
  compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)

castQVariantToNonconst :: QVariantConst -> QVariant
castQVariantToNonconst (QVariantConst ptr') = QVariant $ HoppyF.castPtr ptr'
castQVariantToNonconst (QVariantConstGc fptr' ptr') = QVariantGc fptr' $ HoppyF.castPtr ptr'

instance HoppyFHR.CppPtr QVariant where
  nullptr = QVariant HoppyF.nullPtr
  
  withCppPtr (QVariant ptr') f' = f' ptr'
  withCppPtr (QVariantGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
  
  toPtr (QVariant ptr') = ptr'
  toPtr (QVariantGc _ ptr') = ptr'
  
  touchCppPtr (QVariant _) = HoppyP.return ()
  touchCppPtr (QVariantGc fptr' _) = HoppyF.touchForeignPtr fptr'

instance HoppyFHR.Deletable QVariant where
  delete (QVariant ptr') = delete'QVariant $ (HoppyF.castPtr ptr' :: HoppyF.Ptr QVariantConst)
  delete (QVariantGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "QVariant", " object."]
  
  toGc this'@(QVariant ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip QVariantGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'QVariant :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
  toGc this'@(QVariantGc {}) = HoppyP.return this'

instance HoppyFHR.Copyable QVariant QVariant where copy = newCopy

instance QVariantConstPtr QVariant where
  toQVariantConst (QVariant ptr') = QVariantConst $ (HoppyF.castPtr :: HoppyF.Ptr QVariant -> HoppyF.Ptr QVariantConst) ptr'
  toQVariantConst (QVariantGc fptr' ptr') = QVariantConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QVariant -> HoppyF.Ptr QVariantConst) ptr'

instance QVariantPtr QVariant where
  toQVariant = HoppyP.id

new :: (HoppyP.IO QVariant)
new =
  HoppyP.fmap QVariant
  (new')

newWithBool :: (HoppyP.Bool) -> (HoppyP.IO QVariant)
newWithBool arg'1 =
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVariant
  (newWithBool' arg'1')

newWithByteArray :: (M12.QByteArrayValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithByteArray arg'1 =
  M12.withQByteArrayPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithByteArray' arg'1')

newWithChar :: (M16.QCharValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithChar arg'1 =
  M16.withQCharPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithChar' arg'1')

newWithDouble :: (HoppyP.Double) -> (HoppyP.IO QVariant)
newWithDouble arg'1 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVariant
  (newWithDouble' arg'1')

newWithFloat :: (HoppyP.Float) -> (HoppyP.IO QVariant)
newWithFloat arg'1 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVariant
  (newWithFloat' arg'1')

newWithInt :: (HoppyP.Int) -> (HoppyP.IO QVariant)
newWithInt arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVariant
  (newWithInt' arg'1')

newWithList :: (M208.QListQVariantValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithList arg'1 =
  M208.withQListQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithList' arg'1')

newWithLongLong :: (HoppyFC.CLLong) -> (HoppyP.IO QVariant)
newWithLongLong arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QVariant
  (newWithLongLong' arg'1')

newWithPointF :: (M116.QPointFValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithPointF arg'1 =
  M116.withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithPointF' arg'1')

newWithPoint :: (M114.QPointValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithPoint arg'1 =
  M114.withQPointPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithPoint' arg'1')

newWithRectF :: (M124.QRectFValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithRectF arg'1 =
  M124.withQRectFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithRectF' arg'1')

newWithRect :: (M122.QRectValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithRect arg'1 =
  M122.withQRectPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithRect' arg'1')

newWithSizeF :: (M136.QSizeFValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithSizeF arg'1 =
  M136.withQSizeFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithSizeF' arg'1')

newWithSize :: (M134.QSizeValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithSize arg'1 =
  M134.withQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithSize' arg'1')

newWithString :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithString arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithString' arg'1')

newWithStringList :: (M144.QStringListValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newWithStringList arg'1 =
  M144.withQStringListPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newWithStringList' arg'1')

newWithType :: (QVariantType) -> (HoppyP.IO QVariant)
newWithType arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QVariant
  (newWithType' arg'1')

newWithUInt :: (HoppyFC.CUInt) -> (HoppyP.IO QVariant)
newWithUInt arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QVariant
  (newWithUInt' arg'1')

newWithULongLong :: (HoppyFC.CULLong) -> (HoppyP.IO QVariant)
newWithULongLong arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QVariant
  (newWithULongLong' arg'1')

newCopy :: (QVariantValue arg'1) => (arg'1) -> (HoppyP.IO QVariant)
newCopy arg'1 =
  withQVariantPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QVariant
  (newCopy' arg'1')

class QVariantSuper a where
  downToQVariant :: a -> QVariant


class QVariantSuperConst a where
  downToQVariantConst :: a -> QVariantConst


instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr QVariant)) QVariant where
  assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'

instance QVariantValue a => HoppyFHR.Assignable QVariant a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr QVariant)) QVariant where
  decode = HoppyP.fmap QVariant . HoppyF.peek

instance HoppyFHR.Decodable QVariant (QVariant) where
  decode = HoppyFHR.decode . toQVariantConst

instance HoppyFHR.Decodable QVariantConst (QVariant) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QVariantType =
  Invalid
  | BitArray
  | Bitmap
  | Bool
  | Brush
  | ByteArray
  | Char
  | Color
  | Cursor
  | Date
  | DateTime
  | Double
  | EasingCurve
  | Font
  | Hash
  | Icon
  | Image
  | Int
  | KeySequence
  | Line
  | LineF
  | List
  | Locale
  | LongLong
  | Map
  | Matrix
  | Transform
  | Matrix4X4
  | Palette
  | Pen
  | Pixmap
  | Point
  | PointF
  | Polygon
  | Quaternion
  | Rect
  | RectF
  | RegExp
  | Region
  | Size
  | SizeF
  | SizePolicy
  | String
  | StringList
  | TextFormat
  | TextLength
  | Time
  | UInt
  | ULongLong
  | Url
  | Vector2D
  | Vector3D
  | Vector4D
  | UserType
  | UnknownQVariantType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QVariantType where
  fromCppEnum Invalid = 0
  fromCppEnum BitArray = 13
  fromCppEnum Bitmap = 73
  fromCppEnum Bool = 1
  fromCppEnum Brush = 66
  fromCppEnum ByteArray = 12
  fromCppEnum Char = 7
  fromCppEnum Color = 67
  fromCppEnum Cursor = 74
  fromCppEnum Date = 14
  fromCppEnum DateTime = 16
  fromCppEnum Double = 6
  fromCppEnum EasingCurve = 29
  fromCppEnum Font = 64
  fromCppEnum Hash = 28
  fromCppEnum Icon = 69
  fromCppEnum Image = 70
  fromCppEnum Int = 2
  fromCppEnum KeySequence = 75
  fromCppEnum Line = 23
  fromCppEnum LineF = 24
  fromCppEnum List = 9
  fromCppEnum Locale = 18
  fromCppEnum LongLong = 4
  fromCppEnum Map = 8
  fromCppEnum Matrix = 79
  fromCppEnum Transform = 80
  fromCppEnum Matrix4X4 = 81
  fromCppEnum Palette = 68
  fromCppEnum Pen = 76
  fromCppEnum Pixmap = 65
  fromCppEnum Point = 25
  fromCppEnum PointF = 26
  fromCppEnum Polygon = 71
  fromCppEnum Quaternion = 85
  fromCppEnum Rect = 19
  fromCppEnum RectF = 20
  fromCppEnum RegExp = 27
  fromCppEnum Region = 72
  fromCppEnum Size = 21
  fromCppEnum SizeF = 22
  fromCppEnum SizePolicy = 121
  fromCppEnum String = 10
  fromCppEnum StringList = 11
  fromCppEnum TextFormat = 78
  fromCppEnum TextLength = 77
  fromCppEnum Time = 15
  fromCppEnum UInt = 3
  fromCppEnum ULongLong = 5
  fromCppEnum Url = 17
  fromCppEnum Vector2D = 82
  fromCppEnum Vector3D = 83
  fromCppEnum Vector4D = 84
  fromCppEnum UserType = 1024
  fromCppEnum (UnknownQVariantType n) = n
  
  toCppEnum (0) = Invalid
  toCppEnum (1) = Bool
  toCppEnum (2) = Int
  toCppEnum (3) = UInt
  toCppEnum (4) = LongLong
  toCppEnum (5) = ULongLong
  toCppEnum (6) = Double
  toCppEnum (7) = Char
  toCppEnum (8) = Map
  toCppEnum (9) = List
  toCppEnum (10) = String
  toCppEnum (11) = StringList
  toCppEnum (12) = ByteArray
  toCppEnum (13) = BitArray
  toCppEnum (14) = Date
  toCppEnum (15) = Time
  toCppEnum (16) = DateTime
  toCppEnum (17) = Url
  toCppEnum (18) = Locale
  toCppEnum (19) = Rect
  toCppEnum (20) = RectF
  toCppEnum (21) = Size
  toCppEnum (22) = SizeF
  toCppEnum (23) = Line
  toCppEnum (24) = LineF
  toCppEnum (25) = Point
  toCppEnum (26) = PointF
  toCppEnum (27) = RegExp
  toCppEnum (28) = Hash
  toCppEnum (29) = EasingCurve
  toCppEnum (64) = Font
  toCppEnum (65) = Pixmap
  toCppEnum (66) = Brush
  toCppEnum (67) = Color
  toCppEnum (68) = Palette
  toCppEnum (69) = Icon
  toCppEnum (70) = Image
  toCppEnum (71) = Polygon
  toCppEnum (72) = Region
  toCppEnum (73) = Bitmap
  toCppEnum (74) = Cursor
  toCppEnum (75) = KeySequence
  toCppEnum (76) = Pen
  toCppEnum (77) = TextLength
  toCppEnum (78) = TextFormat
  toCppEnum (79) = Matrix
  toCppEnum (80) = Transform
  toCppEnum (81) = Matrix4X4
  toCppEnum (82) = Vector2D
  toCppEnum (83) = Vector3D
  toCppEnum (84) = Vector4D
  toCppEnum (85) = Quaternion
  toCppEnum (121) = SizePolicy
  toCppEnum (1024) = UserType
  toCppEnum n = UnknownQVariantType n

instance HoppyP.Eq QVariantType where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QVariantType where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)