qtah-qt5-0.8.0: src/Graphics/UI/Qtah/Generated/Core/QMetaProperty.hs

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

module Graphics.UI.Qtah.Generated.Core.QMetaProperty (
  QMetaPropertyValue (..),
  QMetaPropertyConstPtr (..),
  enumerator,
  hasNotifySignal,
  isConstant,
  isDesignable,
  isDesignableWithObject,
  isEnumType,
  isFinal,
  isFlagType,
  isReadable,
  isResettable,
  isScriptable,
  isScriptableWithObject,
  isStored,
  isStoredWithObject,
  isUser,
  isUserWithObject,
  isValid,
  isWritable,
  name,
  notifySignal,
  notifySignalIndex,
  propertyIndex,
  read,
  readOnGadget,
  reset,
  resetOnGadget,
  revision,
  getType,
  typeName,
  userType,
  write,
  writeOnGadget,
  QMetaPropertyPtr (..),
  QMetaPropertyConst (..),
  castQMetaPropertyToConst,
  QMetaProperty (..),
  castQMetaPropertyToNonconst,
  newCopy,
  QMetaPropertySuper (..),
  QMetaPropertySuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QMetaEnum as M80
import qualified Graphics.UI.Qtah.Generated.Core.QMetaMethod as M82
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QVariant as M168
import Prelude (($), (.), (/=), (=<<), (==))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QMetaProperty_newCopy" newCopy' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO (HoppyF.Ptr QMetaProperty)
foreign import ccall "genpop__QMetaProperty_enumerator" enumerator' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO (HoppyF.Ptr M80.QMetaEnumConst)
foreign import ccall "genpop__QMetaProperty_hasNotifySignal" hasNotifySignal' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isConstant" isConstant' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isDesignable" isDesignable' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isDesignableWithObject" isDesignableWithObject' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObjectConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isEnumType" isEnumType' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isFinal" isFinal' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isFlagType" isFlagType' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isReadable" isReadable' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isResettable" isResettable' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isScriptable" isScriptable' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isScriptableWithObject" isScriptableWithObject' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObjectConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isStored" isStored' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isStoredWithObject" isStoredWithObject' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObjectConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isUser" isUser' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isUserWithObject" isUserWithObject' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObjectConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isValid" isValid' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_isWritable" isWritable' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_name" name' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaProperty_notifySignal" notifySignal' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO (HoppyF.Ptr M82.QMetaMethodConst)
foreign import ccall "genpop__QMetaProperty_notifySignalIndex" notifySignalIndex' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaProperty_propertyIndex" propertyIndex' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaProperty_read" read' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObjectConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QMetaProperty_readOnGadget" readOnGadget' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr () -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QMetaProperty_reset" reset' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_resetOnGadget" resetOnGadget' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr () -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_revision" revision' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaProperty_getType" getType' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaProperty_typeName" typeName' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO (HoppyF.Ptr HoppyFC.CChar)
foreign import ccall "genpop__QMetaProperty_userType" userType' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMetaProperty_write" write' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr M94.QObject -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMetaProperty_writeOnGadget" writeOnGadget' ::  HoppyF.Ptr QMetaPropertyConst -> HoppyF.Ptr () -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QMetaProperty" delete'QMetaProperty :: HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMetaProperty" deletePtr'QMetaProperty :: HoppyF.FunPtr (HoppyF.Ptr QMetaPropertyConst -> HoppyP.IO ())

class QMetaPropertyValue a where
  withQMetaPropertyPtr :: a -> (QMetaPropertyConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMetaPropertyConstPtr a => QMetaPropertyValue a where
  withQMetaPropertyPtr = HoppyP.flip ($) . toQMetaPropertyConst

class (HoppyFHR.CppPtr this) => QMetaPropertyConstPtr this where
  toQMetaPropertyConst :: this -> QMetaPropertyConst

enumerator :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyP.IO M80.QMetaEnum)
enumerator arg'1 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M80.QMetaEnumConst) =<<
  (enumerator' arg'1')

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

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

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

isDesignableWithObject :: (QMetaPropertyValue this, M94.QObjectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isDesignableWithObject arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M94.withQObjectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isDesignableWithObject' arg'1' arg'2')

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

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

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

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

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

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

isScriptableWithObject :: (QMetaPropertyValue this, M94.QObjectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isScriptableWithObject arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M94.withQObjectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isScriptableWithObject' arg'1' arg'2')

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

isStoredWithObject :: (QMetaPropertyValue this, M94.QObjectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isStoredWithObject arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M94.withQObjectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isStoredWithObject' arg'1' arg'2')

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

isUserWithObject :: (QMetaPropertyValue this, M94.QObjectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isUserWithObject arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M94.withQObjectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isUserWithObject' arg'1' arg'2')

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

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

name :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
name arg'1 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (name' arg'1')

notifySignal :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyP.IO M82.QMetaMethod)
notifySignal arg'1 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M82.QMetaMethodConst) =<<
  (notifySignal' arg'1')

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

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

read :: (QMetaPropertyValue this, M94.QObjectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M168.QVariant)
read arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M94.withQObjectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (read' arg'1' arg'2')

readOnGadget :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyF.Ptr ()) -> (HoppyP.IO M168.QVariant)
readOnGadget arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (readOnGadget' arg'1' arg'2')

reset :: (QMetaPropertyValue this, M94.QObjectPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
reset arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (reset' arg'1' arg'2')

resetOnGadget :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyF.Ptr ()) -> (HoppyP.IO HoppyP.Bool)
resetOnGadget arg'1 arg'2 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (resetOnGadget' arg'1' arg'2')

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

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

typeName :: (QMetaPropertyValue this) => (this) {- ^ this -} -> (HoppyP.IO (HoppyF.Ptr HoppyFC.CChar))
typeName arg'1 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (typeName' arg'1')

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

write :: (QMetaPropertyValue this, M94.QObjectPtr arg'2, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
write arg'1 arg'2 arg'3 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (write' arg'1' arg'2' arg'3')

writeOnGadget :: (QMetaPropertyValue this, M168.QVariantValue arg'3) => (this) {- ^ this -} -> (HoppyF.Ptr ()) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
writeOnGadget arg'1 arg'2 arg'3 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  M168.withQVariantPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (writeOnGadget' arg'1' arg'2' arg'3')

class (QMetaPropertyConstPtr this) => QMetaPropertyPtr this where
  toQMetaProperty :: this -> QMetaProperty

data QMetaPropertyConst =
    QMetaPropertyConst (HoppyF.Ptr QMetaPropertyConst)
  | QMetaPropertyConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaPropertyConst)
  deriving (HoppyP.Show)

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

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

castQMetaPropertyToConst :: QMetaProperty -> QMetaPropertyConst
castQMetaPropertyToConst (QMetaProperty ptr') = QMetaPropertyConst $ HoppyF.castPtr ptr'
castQMetaPropertyToConst (QMetaPropertyGc fptr' ptr') = QMetaPropertyConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaPropertyConst QMetaProperty where copy = newCopy

instance QMetaPropertyConstPtr QMetaPropertyConst where
  toQMetaPropertyConst = HoppyP.id

data QMetaProperty =
    QMetaProperty (HoppyF.Ptr QMetaProperty)
  | QMetaPropertyGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMetaProperty)
  deriving (HoppyP.Show)

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

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

castQMetaPropertyToNonconst :: QMetaPropertyConst -> QMetaProperty
castQMetaPropertyToNonconst (QMetaPropertyConst ptr') = QMetaProperty $ HoppyF.castPtr ptr'
castQMetaPropertyToNonconst (QMetaPropertyConstGc fptr' ptr') = QMetaPropertyGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QMetaProperty QMetaProperty where copy = newCopy

instance QMetaPropertyConstPtr QMetaProperty where
  toQMetaPropertyConst (QMetaProperty ptr') = QMetaPropertyConst $ (HoppyF.castPtr :: HoppyF.Ptr QMetaProperty -> HoppyF.Ptr QMetaPropertyConst) ptr'
  toQMetaPropertyConst (QMetaPropertyGc fptr' ptr') = QMetaPropertyConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMetaProperty -> HoppyF.Ptr QMetaPropertyConst) ptr'

instance QMetaPropertyPtr QMetaProperty where
  toQMetaProperty = HoppyP.id

newCopy :: (QMetaPropertyValue arg'1) => (arg'1) -> (HoppyP.IO QMetaProperty)
newCopy arg'1 =
  withQMetaPropertyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QMetaProperty
  (newCopy' arg'1')

class QMetaPropertySuper a where
  downToQMetaProperty :: a -> QMetaProperty


class QMetaPropertySuperConst a where
  downToQMetaPropertyConst :: a -> QMetaPropertyConst


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

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

instance HoppyFHR.Decodable QMetaProperty (QMetaProperty) where
  decode = HoppyFHR.decode . toQMetaPropertyConst

instance HoppyFHR.Decodable QMetaPropertyConst (QMetaProperty) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc