QSplitter.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QSplitter (
  castQSplitterToQFrame,
  castQFrameToQSplitter,
  castQSplitterToQWidget,
  castQWidgetToQSplitter,
  castQSplitterToQObject,
  castQObjectToQSplitter,
  QSplitterValue (..),
  QSplitterConstPtr (..),
  childrenCollapsible,
  count,
  handleWidth,
  indexOf,
  isCollapsible,
  opaqueResize,
  orientation,
  widget,
  QSplitterPtr (..),
  addWidget,
  setChildrenCollapsible,
  setHandleWidth,
  insertWidget,
  setOpaqueResize,
  setOrientation,
  refresh,
  setCollapsible,
  setSizes,
  setStretchFactor,
  sizes,
  emitSplitterMoved,
  QSplitterConst (..),
  castQSplitterToConst,
  QSplitter (..),
  castQSplitterToNonconst,
  new,
  newWithParent,
  newWithOrientation,
  newWithOrientationAndParent,
  QSplitterSuper (..),
  QSplitterSuperConst (..),
  ) 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.QList.Int as M192
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
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

foreign import ccall "genpop__QSplitter_new" new' ::  HoppyP.IO (HoppyF.Ptr QSplitter)
foreign import ccall "genpop__QSplitter_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QSplitter)
foreign import ccall "genpop__QSplitter_newWithOrientation" newWithOrientation' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QSplitter)
foreign import ccall "genpop__QSplitter_newWithOrientationAndParent" newWithOrientationAndParent' ::  HoppyFC.CInt -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QSplitter)
foreign import ccall "genpop__QSplitter_addWidget" addWidget' ::  HoppyF.Ptr QSplitter -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_childrenCollapsible" childrenCollapsible' ::  HoppyF.Ptr QSplitterConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSplitter_setChildrenCollapsible" setChildrenCollapsible' ::  HoppyF.Ptr QSplitter -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_count" count' ::  HoppyF.Ptr QSplitterConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSplitter_handleWidth" handleWidth' ::  HoppyF.Ptr QSplitterConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSplitter_setHandleWidth" setHandleWidth' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_indexOf" indexOf' ::  HoppyF.Ptr QSplitterConst -> HoppyF.Ptr M506.QWidget -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSplitter_insertWidget" insertWidget' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_isCollapsible" isCollapsible' ::  HoppyF.Ptr QSplitterConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSplitter_opaqueResize" opaqueResize' ::  HoppyF.Ptr QSplitterConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSplitter_setOpaqueResize" setOpaqueResize' ::  HoppyF.Ptr QSplitter -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_orientation" orientation' ::  HoppyF.Ptr QSplitterConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSplitter_setOrientation" setOrientation' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_refresh" refresh' ::  HoppyF.Ptr QSplitter -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_setCollapsible" setCollapsible' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_setSizes" setSizes' ::  HoppyF.Ptr QSplitter -> HoppyF.Ptr M192.QListIntConst -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_setStretchFactor" setStretchFactor' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSplitter_sizes" sizes' ::  HoppyF.Ptr QSplitter -> HoppyP.IO (HoppyF.Ptr M192.QListIntConst)
foreign import ccall "genpop__QSplitter_widget" widget' ::  HoppyF.Ptr QSplitterConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M506.QWidget)
foreign import ccall "genpop__QSplitter_emitSplitterMoved" emitSplitterMoved' ::  HoppyF.Ptr QSplitter -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QSplitter__QFrame" castQSplitterToQFrame :: HoppyF.Ptr QSplitterConst -> HoppyF.Ptr M400.QFrameConst
foreign import ccall "gencast__QFrame__QSplitter" castQFrameToQSplitter :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr QSplitterConst
foreign import ccall "gencast__QSplitter__QWidget" castQSplitterToQWidget :: HoppyF.Ptr QSplitterConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QSplitter" castQWidgetToQSplitter :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QSplitterConst
foreign import ccall "gencast__QSplitter__QObject" castQSplitterToQObject :: HoppyF.Ptr QSplitterConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QSplitter" castQObjectToQSplitter :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QSplitterConst
foreign import ccall "gendel__QSplitter" delete'QSplitter :: HoppyF.Ptr QSplitterConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSplitter" deletePtr'QSplitter :: HoppyF.FunPtr (HoppyF.Ptr QSplitterConst -> HoppyP.IO ())

class QSplitterValue a where
  withQSplitterPtr :: a -> (QSplitterConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QSplitterConstPtr a => QSplitterValue a where
  withQSplitterPtr = HoppyP.flip ($) . toQSplitterConst

class (M400.QFrameConstPtr this) => QSplitterConstPtr this where
  toQSplitterConst :: this -> QSplitterConst

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

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

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

indexOf :: (QSplitterValue this, M506.QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Int)
indexOf arg'1 arg'2 =
  withQSplitterPtr 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')

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

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

orientation :: (QSplitterValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtOrientation)
orientation arg'1 =
  withQSplitterPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (orientation' arg'1')

widget :: (QSplitterValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M506.QWidget)
widget arg'1 arg'2 =
  withQSplitterPtr 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 (QSplitterConstPtr this, M400.QFramePtr this) => QSplitterPtr this where
  toQSplitter :: this -> QSplitter

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

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

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

insertWidget :: (QSplitterPtr this, M506.QWidgetPtr arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertWidget arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'3) $ \arg'3' ->
  (insertWidget' arg'1' arg'2' arg'3')

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

setOrientation :: (QSplitterPtr this) => (this) {- ^ this -} -> (M190.QtOrientation) -> (HoppyP.IO ())
setOrientation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setOrientation' arg'1' arg'2')

refresh :: (QSplitterPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
refresh arg'1 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (refresh' arg'1')

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

setSizes :: (QSplitterPtr this, M192.QListIntValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSizes arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  M192.withQListIntPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setSizes' arg'1' arg'2')

setStretchFactor :: (QSplitterPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
setStretchFactor arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setStretchFactor' arg'1' arg'2' arg'3')

sizes :: (QSplitterPtr this) => (this) {- ^ this -} -> (HoppyP.IO [HoppyP.Int])
sizes arg'1 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M192.QListIntConst) =<<
  (sizes' arg'1')

emitSplitterMoved :: (QSplitterPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
emitSplitterMoved arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQSplitter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (emitSplitterMoved' arg'1' arg'2' arg'3')

data QSplitterConst =
    QSplitterConst (HoppyF.Ptr QSplitterConst)
  | QSplitterConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSplitterConst)
  deriving (HoppyP.Show)

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

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

castQSplitterToConst :: QSplitter -> QSplitterConst
castQSplitterToConst (QSplitter ptr') = QSplitterConst $ HoppyF.castPtr ptr'
castQSplitterToConst (QSplitterGc fptr' ptr') = QSplitterConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSplitterConstPtr QSplitterConst where
  toQSplitterConst = HoppyP.id

instance M400.QFrameConstPtr QSplitterConst where
  toQFrameConst (QSplitterConst ptr') = M400.QFrameConst $ castQSplitterToQFrame ptr'
  toQFrameConst (QSplitterConstGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQSplitterToQFrame ptr'

instance M506.QWidgetConstPtr QSplitterConst where
  toQWidgetConst (QSplitterConst ptr') = M506.QWidgetConst $ castQSplitterToQWidget ptr'
  toQWidgetConst (QSplitterConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQSplitterToQWidget ptr'

instance M94.QObjectConstPtr QSplitterConst where
  toQObjectConst (QSplitterConst ptr') = M94.QObjectConst $ castQSplitterToQObject ptr'
  toQObjectConst (QSplitterConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSplitterToQObject ptr'

data QSplitter =
    QSplitter (HoppyF.Ptr QSplitter)
  | QSplitterGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSplitter)
  deriving (HoppyP.Show)

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

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

castQSplitterToNonconst :: QSplitterConst -> QSplitter
castQSplitterToNonconst (QSplitterConst ptr') = QSplitter $ HoppyF.castPtr ptr'
castQSplitterToNonconst (QSplitterConstGc fptr' ptr') = QSplitterGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSplitterConstPtr QSplitter where
  toQSplitterConst (QSplitter ptr') = QSplitterConst $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQSplitterConst (QSplitterGc fptr' ptr') = QSplitterConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance QSplitterPtr QSplitter where
  toQSplitter = HoppyP.id

instance M400.QFrameConstPtr QSplitter where
  toQFrameConst (QSplitter ptr') = M400.QFrameConst $ castQSplitterToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQFrameConst (QSplitterGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQSplitterToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance M400.QFramePtr QSplitter where
  toQFrame (QSplitter ptr') = M400.QFrame $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQSplitterToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQFrame (QSplitterGc fptr' ptr') = M400.QFrameGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQSplitterToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance M506.QWidgetConstPtr QSplitter where
  toQWidgetConst (QSplitter ptr') = M506.QWidgetConst $ castQSplitterToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQWidgetConst (QSplitterGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQSplitterToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance M506.QWidgetPtr QSplitter where
  toQWidget (QSplitter ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQSplitterToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQWidget (QSplitterGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQSplitterToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance M94.QObjectConstPtr QSplitter where
  toQObjectConst (QSplitter ptr') = M94.QObjectConst $ castQSplitterToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQObjectConst (QSplitterGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSplitterToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

instance M94.QObjectPtr QSplitter where
  toQObject (QSplitter ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSplitterToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'
  toQObject (QSplitterGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSplitterToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSplitter -> HoppyF.Ptr QSplitterConst) ptr'

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

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

newWithOrientation :: (M190.QtOrientation) -> (HoppyP.IO QSplitter)
newWithOrientation arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QSplitter
  (newWithOrientation' arg'1')

newWithOrientationAndParent :: (M506.QWidgetPtr arg'2) => (M190.QtOrientation) -> (arg'2) -> (HoppyP.IO QSplitter)
newWithOrientationAndParent arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap QSplitter
  (newWithOrientationAndParent' arg'1' arg'2')

class QSplitterSuper a where
  downToQSplitter :: a -> QSplitter

instance QSplitterSuper M400.QFrame where
  downToQSplitter = castQSplitterToNonconst . cast' . M400.castQFrameToConst
    where
      cast' (M400.QFrameConst ptr') = QSplitterConst $ castQFrameToQSplitter ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQFrameToQSplitter ptr'
instance QSplitterSuper M506.QWidget where
  downToQSplitter = castQSplitterToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QSplitterConst $ castQWidgetToQSplitter ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQWidgetToQSplitter ptr'
instance QSplitterSuper M94.QObject where
  downToQSplitter = castQSplitterToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QSplitterConst $ castQObjectToQSplitter ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQObjectToQSplitter ptr'

class QSplitterSuperConst a where
  downToQSplitterConst :: a -> QSplitterConst

instance QSplitterSuperConst M400.QFrameConst where
  downToQSplitterConst = cast'
    where
      cast' (M400.QFrameConst ptr') = QSplitterConst $ castQFrameToQSplitter ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQFrameToQSplitter ptr'
instance QSplitterSuperConst M506.QWidgetConst where
  downToQSplitterConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QSplitterConst $ castQWidgetToQSplitter ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQWidgetToQSplitter ptr'
instance QSplitterSuperConst M94.QObjectConst where
  downToQSplitterConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QSplitterConst $ castQObjectToQSplitter ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSplitterConstGc fptr' $ castQObjectToQSplitter ptr'

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

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