QActionGroup.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QActionGroup (
  castQActionGroupToQObject,
  castQObjectToQActionGroup,
  QActionGroupValue (..),
  QActionGroupConstPtr (..),
  checkedAction,
  isEnabled,
  isExclusive,
  isVisible,
  QActionGroupPtr (..),
  addAction,
  addNewAction,
  addNewActionWithIcon,
  setEnabled,
  setExclusive,
  removeAction,
  setDisabled,
  setVisible,
  emitHovered,
  emitTriggered,
  QActionGroupConst (..),
  castQActionGroupToConst,
  QActionGroup (..),
  castQActionGroupToNonconst,
  new,
  QActionGroupSuper (..),
  QActionGroupSuperConst (..),
  ) where

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.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAction as M368
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QActionGroup_new" new' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QActionGroup)
foreign import ccall "genpop__QActionGroup_addAction" addAction' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M368.QAction -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QActionGroup_addNewAction" addNewAction' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QActionGroup_addNewActionWithIcon" addNewActionWithIcon' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QActionGroup_checkedAction" checkedAction' ::  HoppyF.Ptr QActionGroupConst -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QActionGroup_isEnabled" isEnabled' ::  HoppyF.Ptr QActionGroupConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QActionGroup_setEnabled" setEnabled' ::  HoppyF.Ptr QActionGroup -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_isExclusive" isExclusive' ::  HoppyF.Ptr QActionGroupConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QActionGroup_setExclusive" setExclusive' ::  HoppyF.Ptr QActionGroup -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_removeAction" removeAction' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_setDisabled" setDisabled' ::  HoppyF.Ptr QActionGroup -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_isVisible" isVisible' ::  HoppyF.Ptr QActionGroupConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QActionGroup_setVisible" setVisible' ::  HoppyF.Ptr QActionGroup -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_emitHovered" emitHovered' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QActionGroup_emitTriggered" emitTriggered' ::  HoppyF.Ptr QActionGroup -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "gencast__QActionGroup__QObject" castQActionGroupToQObject :: HoppyF.Ptr QActionGroupConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QActionGroup" castQObjectToQActionGroup :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QActionGroupConst
foreign import ccall "gendel__QActionGroup" delete'QActionGroup :: HoppyF.Ptr QActionGroupConst -> HoppyP.IO ()
foreign import ccall "&gendel__QActionGroup" deletePtr'QActionGroup :: HoppyF.FunPtr (HoppyF.Ptr QActionGroupConst -> HoppyP.IO ())

class QActionGroupValue a where
  withQActionGroupPtr :: a -> (QActionGroupConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QActionGroupConstPtr a => QActionGroupValue a where
  withQActionGroupPtr = HoppyP.flip ($) . toQActionGroupConst

class (M94.QObjectConstPtr this) => QActionGroupConstPtr this where
  toQActionGroupConst :: this -> QActionGroupConst

checkedAction :: (QActionGroupValue this) => (this) {- ^ this -} -> (HoppyP.IO M368.QAction)
checkedAction arg'1 =
  withQActionGroupPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M368.QAction
  (checkedAction' arg'1')

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

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

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

class (QActionGroupConstPtr this, M94.QObjectPtr this) => QActionGroupPtr this where
  toQActionGroup :: this -> QActionGroup

addAction :: (QActionGroupPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M368.QAction)
addAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  HoppyP.fmap M368.QAction
  (addAction' arg'1' arg'2')

addNewAction :: (QActionGroupPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M368.QAction)
addNewAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M368.QAction
  (addNewAction' arg'1' arg'2')

addNewActionWithIcon :: (QActionGroupPtr this, M288.QIconValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO M368.QAction)
addNewActionWithIcon arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  M288.withQIconPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap M368.QAction
  (addNewActionWithIcon' arg'1' arg'2' arg'3')

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

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

removeAction :: (QActionGroupPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (removeAction' arg'1' arg'2')

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

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

emitHovered :: (QActionGroupPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitHovered arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (emitHovered' arg'1' arg'2')

emitTriggered :: (QActionGroupPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitTriggered arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQActionGroup arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (emitTriggered' arg'1' arg'2')

data QActionGroupConst =
    QActionGroupConst (HoppyF.Ptr QActionGroupConst)
  | QActionGroupConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QActionGroupConst)
  deriving (HoppyP.Show)

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

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

castQActionGroupToConst :: QActionGroup -> QActionGroupConst
castQActionGroupToConst (QActionGroup ptr') = QActionGroupConst $ HoppyF.castPtr ptr'
castQActionGroupToConst (QActionGroupGc fptr' ptr') = QActionGroupConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QActionGroupConstPtr QActionGroupConst where
  toQActionGroupConst = HoppyP.id

instance M94.QObjectConstPtr QActionGroupConst where
  toQObjectConst (QActionGroupConst ptr') = M94.QObjectConst $ castQActionGroupToQObject ptr'
  toQObjectConst (QActionGroupConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQActionGroupToQObject ptr'

data QActionGroup =
    QActionGroup (HoppyF.Ptr QActionGroup)
  | QActionGroupGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QActionGroup)
  deriving (HoppyP.Show)

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

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

castQActionGroupToNonconst :: QActionGroupConst -> QActionGroup
castQActionGroupToNonconst (QActionGroupConst ptr') = QActionGroup $ HoppyF.castPtr ptr'
castQActionGroupToNonconst (QActionGroupConstGc fptr' ptr') = QActionGroupGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QActionGroupConstPtr QActionGroup where
  toQActionGroupConst (QActionGroup ptr') = QActionGroupConst $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'
  toQActionGroupConst (QActionGroupGc fptr' ptr') = QActionGroupConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'

instance QActionGroupPtr QActionGroup where
  toQActionGroup = HoppyP.id

instance M94.QObjectConstPtr QActionGroup where
  toQObjectConst (QActionGroup ptr') = M94.QObjectConst $ castQActionGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'
  toQObjectConst (QActionGroupGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQActionGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'

instance M94.QObjectPtr QActionGroup where
  toQObject (QActionGroup ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQActionGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'
  toQObject (QActionGroupGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQActionGroupToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QActionGroup -> HoppyF.Ptr QActionGroupConst) ptr'

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

class QActionGroupSuper a where
  downToQActionGroup :: a -> QActionGroup

instance QActionGroupSuper M94.QObject where
  downToQActionGroup = castQActionGroupToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QActionGroupConst $ castQObjectToQActionGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QActionGroupConstGc fptr' $ castQObjectToQActionGroup ptr'

class QActionGroupSuperConst a where
  downToQActionGroupConst :: a -> QActionGroupConst

instance QActionGroupSuperConst M94.QObjectConst where
  downToQActionGroupConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QActionGroupConst $ castQObjectToQActionGroup ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QActionGroupConstGc fptr' $ castQObjectToQActionGroup ptr'

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

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