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

module Graphics.UI.Qtah.Generated.Widgets.QToolBox (
  castQToolBoxToQFrame,
  castQFrameToQToolBox,
  castQToolBoxToQWidget,
  castQWidgetToQToolBox,
  castQToolBoxToQObject,
  castQObjectToQToolBox,
  QToolBoxValue (..),
  QToolBoxConstPtr (..),
  count,
  currentIndex,
  currentWidget,
  indexOf,
  isItemEnabled,
  itemIcon,
  itemText,
  itemToolTip,
  widget,
  QToolBoxPtr (..),
  addItemWithIcon,
  addItem,
  insertItemWithIcon,
  insertItem,
  removeItem,
  setItemEnabled,
  setItemIcon,
  setItemText,
  setItemToolTip,
  setCurrentIndex,
  setCurrentWidget,
  emitCurrentChanged,
  QToolBoxConst (..),
  castQToolBoxToConst,
  QToolBox (..),
  castQToolBoxToNonconst,
  new,
  newWithParent,
  newWithParentAndFlags,
  QToolBoxSuper (..),
  QToolBoxSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import qualified Graphics.UI.Qtah.Generated.Widgets.QFrame as M400
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QToolBox_new" new' ::  HoppyP.IO (HoppyF.Ptr QToolBox)
foreign import ccall "genpop__QToolBox_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QToolBox)
foreign import ccall "genpop__QToolBox_newWithParentAndFlags" newWithParentAndFlags' ::  HoppyF.Ptr M506.QWidget -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QToolBox)
foreign import ccall "genpop__QToolBox_count" count' ::  HoppyF.Ptr QToolBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_currentIndex" currentIndex' ::  HoppyF.Ptr QToolBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_addItemWithIcon" addItemWithIcon' ::  HoppyF.Ptr QToolBox -> HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_addItem" addItem' ::  HoppyF.Ptr QToolBox -> HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_currentWidget" currentWidget' ::  HoppyF.Ptr QToolBoxConst -> HoppyP.IO (HoppyF.Ptr M506.QWidget)
foreign import ccall "genpop__QToolBox_indexOf" indexOf' ::  HoppyF.Ptr QToolBoxConst -> HoppyF.Ptr M506.QWidget -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_insertItemWithIcon" insertItemWithIcon' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_insertItem" insertItem' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBox_isItemEnabled" isItemEnabled' ::  HoppyF.Ptr QToolBoxConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QToolBox_itemIcon" itemIcon' ::  HoppyF.Ptr QToolBoxConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M288.QIconConst)
foreign import ccall "genpop__QToolBox_itemText" itemText' ::  HoppyF.Ptr QToolBoxConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QToolBox_itemToolTip" itemToolTip' ::  HoppyF.Ptr QToolBoxConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QToolBox_removeItem" removeItem' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_setItemEnabled" setItemEnabled' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_setItemIcon" setItemIcon' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_setItemText" setItemText' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_setItemToolTip" setItemToolTip' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_widget" widget' ::  HoppyF.Ptr QToolBoxConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M506.QWidget)
foreign import ccall "genpop__QToolBox_setCurrentIndex" setCurrentIndex' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_setCurrentWidget" setCurrentWidget' ::  HoppyF.Ptr QToolBox -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QToolBox_emitCurrentChanged" emitCurrentChanged' ::  HoppyF.Ptr QToolBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QToolBox__QFrame" castQToolBoxToQFrame :: HoppyF.Ptr QToolBoxConst -> HoppyF.Ptr M400.QFrameConst
foreign import ccall "gencast__QFrame__QToolBox" castQFrameToQToolBox :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr QToolBoxConst
foreign import ccall "gencast__QToolBox__QWidget" castQToolBoxToQWidget :: HoppyF.Ptr QToolBoxConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QToolBox" castQWidgetToQToolBox :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QToolBoxConst
foreign import ccall "gencast__QToolBox__QObject" castQToolBoxToQObject :: HoppyF.Ptr QToolBoxConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QToolBox" castQObjectToQToolBox :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QToolBoxConst
foreign import ccall "gendel__QToolBox" delete'QToolBox :: HoppyF.Ptr QToolBoxConst -> HoppyP.IO ()
foreign import ccall "&gendel__QToolBox" deletePtr'QToolBox :: HoppyF.FunPtr (HoppyF.Ptr QToolBoxConst -> HoppyP.IO ())

class QToolBoxValue a where
  withQToolBoxPtr :: a -> (QToolBoxConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QToolBoxConstPtr a => QToolBoxValue a where
  withQToolBoxPtr = HoppyP.flip ($) . toQToolBoxConst

class (M400.QFrameConstPtr this) => QToolBoxConstPtr this where
  toQToolBoxConst :: this -> QToolBoxConst

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

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

currentWidget :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M506.QWidget)
currentWidget arg'1 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M506.QWidget
  (currentWidget' arg'1')

indexOf :: (QToolBoxValue this, M506.QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (indexOf' arg'1' arg'2')

isItemEnabled :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
isItemEnabled arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isItemEnabled' arg'1' arg'2')

itemIcon :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M288.QIcon)
itemIcon arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M288.QIconConst) =<<
  (itemIcon' arg'1' arg'2')

itemText :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
itemText arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (itemText' arg'1' arg'2')

itemToolTip :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
itemToolTip arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (itemToolTip' arg'1' arg'2')

widget :: (QToolBoxValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M506.QWidget)
widget arg'1 arg'2 =
  withQToolBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M506.QWidget
  (widget' arg'1' arg'2')

class (QToolBoxConstPtr this, M400.QFramePtr this) => QToolBoxPtr this where
  toQToolBox :: this -> QToolBox

addItemWithIcon :: (QToolBoxPtr this, M506.QWidgetPtr arg'2, M288.QIconValue arg'3, M142.QStringValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO HoppyP.Int)
addItemWithIcon arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  M288.withQIconPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (addItemWithIcon' arg'1' arg'2' arg'3' arg'4')

addItem :: (QToolBoxPtr this, M506.QWidgetPtr arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Int)
addItem arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (addItem' arg'1' arg'2' arg'3')

insertItemWithIcon :: (QToolBoxPtr this, M506.QWidgetPtr arg'3, M288.QIconValue arg'4, M142.QStringValue arg'5) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (arg'4) -> (arg'5) -> (HoppyP.IO HoppyP.Int)
insertItemWithIcon arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'3) $ \arg'3' ->
  M288.withQIconPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  M142.withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (insertItemWithIcon' arg'1' arg'2' arg'3' arg'4' arg'5')

insertItem :: (QToolBoxPtr this, M506.QWidgetPtr arg'3, M142.QStringValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (arg'4) -> (HoppyP.IO HoppyP.Int)
insertItem arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'3) $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (insertItem' arg'1' arg'2' arg'3' arg'4')

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

setItemEnabled :: (QToolBoxPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Bool) -> (HoppyP.IO ())
setItemEnabled arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBox 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' ->
  (setItemEnabled' arg'1' arg'2' arg'3')

setItemIcon :: (QToolBoxPtr this, M288.QIconValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
setItemIcon arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M288.withQIconPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setItemIcon' arg'1' arg'2' arg'3')

setItemText :: (QToolBoxPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
setItemText arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setItemText' arg'1' arg'2' arg'3')

setItemToolTip :: (QToolBoxPtr this, M142.QStringValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
setItemToolTip arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setItemToolTip' arg'1' arg'2' arg'3')

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

setCurrentWidget :: (QToolBoxPtr this, M506.QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setCurrentWidget arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  (setCurrentWidget' arg'1' arg'2')

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

data QToolBoxConst =
    QToolBoxConst (HoppyF.Ptr QToolBoxConst)
  | QToolBoxConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QToolBoxConst)
  deriving (HoppyP.Show)

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

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

castQToolBoxToConst :: QToolBox -> QToolBoxConst
castQToolBoxToConst (QToolBox ptr') = QToolBoxConst $ HoppyF.castPtr ptr'
castQToolBoxToConst (QToolBoxGc fptr' ptr') = QToolBoxConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QToolBoxConstPtr QToolBoxConst where
  toQToolBoxConst = HoppyP.id

instance M400.QFrameConstPtr QToolBoxConst where
  toQFrameConst (QToolBoxConst ptr') = M400.QFrameConst $ castQToolBoxToQFrame ptr'
  toQFrameConst (QToolBoxConstGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQToolBoxToQFrame ptr'

instance M506.QWidgetConstPtr QToolBoxConst where
  toQWidgetConst (QToolBoxConst ptr') = M506.QWidgetConst $ castQToolBoxToQWidget ptr'
  toQWidgetConst (QToolBoxConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQToolBoxToQWidget ptr'

instance M94.QObjectConstPtr QToolBoxConst where
  toQObjectConst (QToolBoxConst ptr') = M94.QObjectConst $ castQToolBoxToQObject ptr'
  toQObjectConst (QToolBoxConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQToolBoxToQObject ptr'

data QToolBox =
    QToolBox (HoppyF.Ptr QToolBox)
  | QToolBoxGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QToolBox)
  deriving (HoppyP.Show)

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

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

castQToolBoxToNonconst :: QToolBoxConst -> QToolBox
castQToolBoxToNonconst (QToolBoxConst ptr') = QToolBox $ HoppyF.castPtr ptr'
castQToolBoxToNonconst (QToolBoxConstGc fptr' ptr') = QToolBoxGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QToolBoxConstPtr QToolBox where
  toQToolBoxConst (QToolBox ptr') = QToolBoxConst $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQToolBoxConst (QToolBoxGc fptr' ptr') = QToolBoxConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance QToolBoxPtr QToolBox where
  toQToolBox = HoppyP.id

instance M400.QFrameConstPtr QToolBox where
  toQFrameConst (QToolBox ptr') = M400.QFrameConst $ castQToolBoxToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQFrameConst (QToolBoxGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQToolBoxToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance M400.QFramePtr QToolBox where
  toQFrame (QToolBox ptr') = M400.QFrame $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQToolBoxToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQFrame (QToolBoxGc fptr' ptr') = M400.QFrameGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQToolBoxToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance M506.QWidgetConstPtr QToolBox where
  toQWidgetConst (QToolBox ptr') = M506.QWidgetConst $ castQToolBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQWidgetConst (QToolBoxGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQToolBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance M506.QWidgetPtr QToolBox where
  toQWidget (QToolBox ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQToolBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQWidget (QToolBoxGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQToolBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance M94.QObjectConstPtr QToolBox where
  toQObjectConst (QToolBox ptr') = M94.QObjectConst $ castQToolBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQObjectConst (QToolBoxGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQToolBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

instance M94.QObjectPtr QToolBox where
  toQObject (QToolBox ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQToolBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'
  toQObject (QToolBoxGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQToolBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBox -> HoppyF.Ptr QToolBoxConst) ptr'

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

newWithParent :: (M506.QWidgetPtr arg'1) => (arg'1) -> (HoppyP.IO QToolBox)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QToolBox
  (newWithParent' arg'1')

newWithParentAndFlags :: (M506.QWidgetPtr arg'1, M190.IsQtWindowFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QToolBox)
newWithParentAndFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QToolBox
  (newWithParentAndFlags' arg'1' arg'2')

class QToolBoxSuper a where
  downToQToolBox :: a -> QToolBox

instance QToolBoxSuper M400.QFrame where
  downToQToolBox = castQToolBoxToNonconst . cast' . M400.castQFrameToConst
    where
      cast' (M400.QFrameConst ptr') = QToolBoxConst $ castQFrameToQToolBox ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQFrameToQToolBox ptr'
instance QToolBoxSuper M506.QWidget where
  downToQToolBox = castQToolBoxToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QToolBoxConst $ castQWidgetToQToolBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQWidgetToQToolBox ptr'
instance QToolBoxSuper M94.QObject where
  downToQToolBox = castQToolBoxToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QToolBoxConst $ castQObjectToQToolBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQObjectToQToolBox ptr'

class QToolBoxSuperConst a where
  downToQToolBoxConst :: a -> QToolBoxConst

instance QToolBoxSuperConst M400.QFrameConst where
  downToQToolBoxConst = cast'
    where
      cast' (M400.QFrameConst ptr') = QToolBoxConst $ castQFrameToQToolBox ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQFrameToQToolBox ptr'
instance QToolBoxSuperConst M506.QWidgetConst where
  downToQToolBoxConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QToolBoxConst $ castQWidgetToQToolBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQWidgetToQToolBox ptr'
instance QToolBoxSuperConst M94.QObjectConst where
  downToQToolBoxConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QToolBoxConst $ castQObjectToQToolBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QToolBoxConstGc fptr' $ castQObjectToQToolBox ptr'

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

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