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

module Graphics.UI.Qtah.Generated.Widgets.QButtonGroup (
  castQButtonGroupToQObject,
  castQObjectToQButtonGroup,
  QButtonGroupValue (..),
  QButtonGroupConstPtr (..),
  button,
  buttons,
  checkedButton,
  checkedId,
  exclusive,
  id,
  QButtonGroupPtr (..),
  addButton,
  addButtonWithId,
  setExclusive,
  removeButton,
  setId,
  emitButtonClicked,
  emitButtonClickedId,
  emitButtonPressed,
  emitButtonPressedId,
  emitButtonReleased,
  emitButtonReleasedId,
  emitButtonToggled,
  emitButtonToggledId,
  QButtonGroupConst (..),
  castQButtonGroupToConst,
  QButtonGroup (..),
  castQButtonGroupToNonconst,
  new,
  newWithParent,
  QButtonGroupSuper (..),
  QButtonGroupSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QList.QAbstractButton as M194
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractButton as M354
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QButtonGroup_new" new' ::  HoppyP.IO (HoppyF.Ptr QButtonGroup)
foreign import ccall "genpop__QButtonGroup_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QButtonGroup)
foreign import ccall "genpop__QButtonGroup_addButton" addButton' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_addButtonWithId" addButtonWithId' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_button" button' ::  HoppyF.Ptr QButtonGroupConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M354.QAbstractButton)
foreign import ccall "genpop__QButtonGroup_buttons" buttons' ::  HoppyF.Ptr QButtonGroupConst -> HoppyP.IO (HoppyF.Ptr M194.QListQAbstractButtonConst)
foreign import ccall "genpop__QButtonGroup_checkedButton" checkedButton' ::  HoppyF.Ptr QButtonGroupConst -> HoppyP.IO (HoppyF.Ptr M354.QAbstractButton)
foreign import ccall "genpop__QButtonGroup_checkedId" checkedId' ::  HoppyF.Ptr QButtonGroupConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QButtonGroup_exclusive" exclusive' ::  HoppyF.Ptr QButtonGroupConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QButtonGroup_setExclusive" setExclusive' ::  HoppyF.Ptr QButtonGroup -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_id" id' ::  HoppyF.Ptr QButtonGroupConst -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QButtonGroup_removeButton" removeButton' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_setId" setId' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonClicked" emitButtonClicked' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonClickedId" emitButtonClickedId' ::  HoppyF.Ptr QButtonGroup -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonPressed" emitButtonPressed' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonPressedId" emitButtonPressedId' ::  HoppyF.Ptr QButtonGroup -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonReleased" emitButtonReleased' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonReleasedId" emitButtonReleasedId' ::  HoppyF.Ptr QButtonGroup -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonToggled" emitButtonToggled' ::  HoppyF.Ptr QButtonGroup -> HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QButtonGroup_emitButtonToggledId" emitButtonToggledId' ::  HoppyF.Ptr QButtonGroup -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "gencast__QButtonGroup__QObject" castQButtonGroupToQObject :: HoppyF.Ptr QButtonGroupConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QButtonGroup" castQObjectToQButtonGroup :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QButtonGroupConst
foreign import ccall "gendel__QButtonGroup" delete'QButtonGroup :: HoppyF.Ptr QButtonGroupConst -> HoppyP.IO ()
foreign import ccall "&gendel__QButtonGroup" deletePtr'QButtonGroup :: HoppyF.FunPtr (HoppyF.Ptr QButtonGroupConst -> HoppyP.IO ())

class QButtonGroupValue a where
  withQButtonGroupPtr :: a -> (QButtonGroupConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QButtonGroupConstPtr a => QButtonGroupValue a where
  withQButtonGroupPtr = HoppyP.flip ($) . toQButtonGroupConst

class (M94.QObjectConstPtr this) => QButtonGroupConstPtr this where
  toQButtonGroupConst :: this -> QButtonGroupConst

button :: (QButtonGroupValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M354.QAbstractButton)
button arg'1 arg'2 =
  withQButtonGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M354.QAbstractButton
  (button' arg'1' arg'2')

buttons :: (QButtonGroupValue this) => (this) {- ^ this -} -> (HoppyP.IO [M354.QAbstractButton])
buttons arg'1 =
  withQButtonGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M194.QListQAbstractButtonConst) =<<
  (buttons' arg'1')

checkedButton :: (QButtonGroupValue this) => (this) {- ^ this -} -> (HoppyP.IO M354.QAbstractButton)
checkedButton arg'1 =
  withQButtonGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M354.QAbstractButton
  (checkedButton' arg'1')

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

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

id :: (QButtonGroupValue this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
id arg'1 arg'2 =
  withQButtonGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (id' arg'1' arg'2')

class (QButtonGroupConstPtr this, M94.QObjectPtr this) => QButtonGroupPtr this where
  toQButtonGroup :: this -> QButtonGroup

addButton :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
addButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (addButton' arg'1' arg'2')

addButtonWithId :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
addButtonWithId arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (addButtonWithId' arg'1' arg'2' arg'3')

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

removeButton :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (removeButton' arg'1' arg'2')

setId :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
setId arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setId' arg'1' arg'2' arg'3')

emitButtonClicked :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitButtonClicked arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (emitButtonClicked' arg'1' arg'2')

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

emitButtonPressed :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitButtonPressed arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (emitButtonPressed' arg'1' arg'2')

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

emitButtonReleased :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitButtonReleased arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (emitButtonReleased' arg'1' arg'2')

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

emitButtonToggled :: (QButtonGroupPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Bool) -> (HoppyP.IO ())
emitButtonToggled arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (emitButtonToggled' arg'1' arg'2' arg'3')

emitButtonToggledId :: (QButtonGroupPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Bool) -> (HoppyP.IO ())
emitButtonToggledId arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQButtonGroup arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (emitButtonToggledId' arg'1' arg'2' arg'3')

data QButtonGroupConst =
    QButtonGroupConst (HoppyF.Ptr QButtonGroupConst)
  | QButtonGroupConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QButtonGroupConst)
  deriving (HoppyP.Show)

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

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

castQButtonGroupToConst :: QButtonGroup -> QButtonGroupConst
castQButtonGroupToConst (QButtonGroup ptr') = QButtonGroupConst $ HoppyF.castPtr ptr'
castQButtonGroupToConst (QButtonGroupGc fptr' ptr') = QButtonGroupConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QButtonGroupConstPtr QButtonGroupConst where
  toQButtonGroupConst = HoppyP.id

instance M94.QObjectConstPtr QButtonGroupConst where
  toQObjectConst (QButtonGroupConst ptr') = M94.QObjectConst $ castQButtonGroupToQObject ptr'
  toQObjectConst (QButtonGroupConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQButtonGroupToQObject ptr'

data QButtonGroup =
    QButtonGroup (HoppyF.Ptr QButtonGroup)
  | QButtonGroupGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QButtonGroup)
  deriving (HoppyP.Show)

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

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

castQButtonGroupToNonconst :: QButtonGroupConst -> QButtonGroup
castQButtonGroupToNonconst (QButtonGroupConst ptr') = QButtonGroup $ HoppyF.castPtr ptr'
castQButtonGroupToNonconst (QButtonGroupConstGc fptr' ptr') = QButtonGroupGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QButtonGroupConstPtr QButtonGroup where
  toQButtonGroupConst (QButtonGroup ptr') = QButtonGroupConst $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'
  toQButtonGroupConst (QButtonGroupGc fptr' ptr') = QButtonGroupConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'

instance QButtonGroupPtr QButtonGroup where
  toQButtonGroup = HoppyP.id

instance M94.QObjectConstPtr QButtonGroup where
  toQObjectConst (QButtonGroup ptr') = M94.QObjectConst $ castQButtonGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'
  toQObjectConst (QButtonGroupGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQButtonGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'

instance M94.QObjectPtr QButtonGroup where
  toQObject (QButtonGroup ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQButtonGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'
  toQObject (QButtonGroupGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQButtonGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QButtonGroup -> HoppyF.Ptr QButtonGroupConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QButtonGroup)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QButtonGroup
  (newWithParent' arg'1')

class QButtonGroupSuper a where
  downToQButtonGroup :: a -> QButtonGroup

instance QButtonGroupSuper M94.QObject where
  downToQButtonGroup = castQButtonGroupToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QButtonGroupConst $ castQObjectToQButtonGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QButtonGroupConstGc fptr' $ castQObjectToQButtonGroup ptr'

class QButtonGroupSuperConst a where
  downToQButtonGroupConst :: a -> QButtonGroupConst

instance QButtonGroupSuperConst M94.QObjectConst where
  downToQButtonGroupConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QButtonGroupConst $ castQObjectToQButtonGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QButtonGroupConstGc fptr' $ castQObjectToQButtonGroup ptr'

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

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