qtah-qt5-0.8.0: src/Graphics/UI/Qtah/Internal/Callback.hs

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

module Graphics.UI.Qtah.Internal.Callback (
  callbackBoolVoid_newFunPtr,
  callbackBoolVoid_new,
  callbackDirectionVoid_newFunPtr,
  callbackDirectionVoid_new,
  callbackDockWidgetAreaVoid_newFunPtr,
  callbackDockWidgetAreaVoid_new,
  callbackDockWidgetAreasVoid_newFunPtr,
  callbackDockWidgetAreasVoid_new,
  callbackDoubleVoid_newFunPtr,
  callbackDoubleVoid_new,
  callbackIntBoolVoid_newFunPtr,
  callbackIntBoolVoid_new,
  callbackIntExitStatusVoid_newFunPtr,
  callbackIntExitStatusVoid_new,
  callbackIntIntVoid_newFunPtr,
  callbackIntIntVoid_new,
  callbackIntQlonglongVoid_newFunPtr,
  callbackIntQlonglongVoid_new,
  callbackIntVoid_newFunPtr,
  callbackIntVoid_new,
  callbackOrientationIntIntVoid_newFunPtr,
  callbackOrientationIntIntVoid_new,
  callbackOrientationVoid_newFunPtr,
  callbackOrientationVoid_new,
  callbackProcessErrorVoid_newFunPtr,
  callbackProcessErrorVoid_new,
  callbackProcessStateVoid_newFunPtr,
  callbackProcessStateVoid_new,
  callbackPtrQAbstractButtonBoolVoid_newFunPtr,
  callbackPtrQAbstractButtonBoolVoid_new,
  callbackPtrQAbstractButtonVoid_newFunPtr,
  callbackPtrQAbstractButtonVoid_new,
  callbackPtrQAbstractItemModelVoid_newFunPtr,
  callbackPtrQAbstractItemModelVoid_new,
  callbackPtrQActionVoid_newFunPtr,
  callbackPtrQActionVoid_new,
  callbackPtrQGraphicsItemPtrQEventBool_newFunPtr,
  callbackPtrQGraphicsItemPtrQEventBool_new,
  callbackPtrQMdiSubWindowVoid_newFunPtr,
  callbackPtrQMdiSubWindowVoid_new,
  callbackPtrQObjectPtrQEventBool_newFunPtr,
  callbackPtrQObjectPtrQEventBool_new,
  callbackPtrQObjectVoid_newFunPtr,
  callbackPtrQObjectVoid_new,
  callbackPtrQPaintEventVoid_newFunPtr,
  callbackPtrQPaintEventVoid_new,
  callbackPtrQTreeWidgetItemIntVoid_newFunPtr,
  callbackPtrQTreeWidgetItemIntVoid_new,
  callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_newFunPtr,
  callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new,
  callbackPtrQTreeWidgetItemVoid_newFunPtr,
  callbackPtrQTreeWidgetItemVoid_new,
  callbackPtrQWidgetPtrQWidgetVoid_newFunPtr,
  callbackPtrQWidgetPtrQWidgetVoid_new,
  callbackQAbstractAnimationVoid_newFunPtr,
  callbackQAbstractAnimationVoid_new,
  callbackQAbstractSliderActionVoid_newFunPtr,
  callbackQAbstractSliderActionVoid_new,
  callbackQClipboardModeVoid_newFunPtr,
  callbackQClipboardModeVoid_new,
  callbackQDateVoid_newFunPtr,
  callbackQDateVoid_new,
  callbackQDockWidgetFeaturesVoid_newFunPtr,
  callbackQDockWidgetFeaturesVoid_new,
  callbackQModelIndexIntIntQModelIndexIntVoid_newFunPtr,
  callbackQModelIndexIntIntQModelIndexIntVoid_new,
  callbackQModelIndexIntIntVoid_newFunPtr,
  callbackQModelIndexIntIntVoid_new,
  callbackQModelIndexQModelIndexQVectorIntVoid_newFunPtr,
  callbackQModelIndexQModelIndexQVectorIntVoid_new,
  callbackQModelIndexQModelIndexVoid_newFunPtr,
  callbackQModelIndexQModelIndexVoid_new,
  callbackQModelIndexVoid_newFunPtr,
  callbackQModelIndexVoid_new,
  callbackQPointVoid_newFunPtr,
  callbackQPointVoid_new,
  callbackQSizeVoid_newFunPtr,
  callbackQSizeVoid_new,
  callbackQStringVoid_newFunPtr,
  callbackQStringVoid_new,
  callbackQSystemTrayIconActivationReasonVoid_newFunPtr,
  callbackQSystemTrayIconActivationReasonVoid_new,
  callbackQWindowVisibilityVoid_newFunPtr,
  callbackQWindowVisibilityVoid_new,
  callbackQlonglongVoid_newFunPtr,
  callbackQlonglongVoid_new,
  callbackQrealVoid_newFunPtr,
  callbackQrealVoid_new,
  callbackRefConstQIconVoid_newFunPtr,
  callbackRefConstQIconVoid_new,
  callbackRefConstQItemSelectionRefConstQItemSelectionVoid_newFunPtr,
  callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new,
  callbackRefConstQListQModelIndexVoid_newFunPtr,
  callbackRefConstQListQModelIndexVoid_new,
  callbackRefConstQModelIndexVoid_newFunPtr,
  callbackRefConstQModelIndexVoid_new,
  callbackRefConstQVariantVoid_newFunPtr,
  callbackRefConstQVariantVoid_new,
  callbackScreenOrientationVoid_newFunPtr,
  callbackScreenOrientationVoid_new,
  callbackStateStateVoid_newFunPtr,
  callbackStateStateVoid_new,
  callbackToolBarAreasVoid_newFunPtr,
  callbackToolBarAreasVoid_new,
  callbackToolButtonStyleVoid_newFunPtr,
  callbackToolButtonStyleVoid_new,
  callbackVoid_newFunPtr,
  callbackVoid_new,
  callbackWindowModalityVoid_newFunPtr,
  callbackWindowModalityVoid_new,
  callbackWindowStateVoid_newFunPtr,
  callbackWindowStateVoid_new,
  callbackWindowStatesWindowStatesVoid_newFunPtr,
  callbackWindowStatesWindowStatesVoid_new,
  ) where

import qualified Data.Int as HoppyDI
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HPoint as HPoint
import qualified Graphics.UI.Qtah.Core.HSize as HSize
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QAbstractAnimation as M2
import qualified Graphics.UI.Qtah.Generated.Core.QAbstractItemModel as M4
import qualified Graphics.UI.Qtah.Generated.Core.QDate as M22
import qualified Graphics.UI.Qtah.Generated.Core.QEvent as M34
import qualified Graphics.UI.Qtah.Generated.Core.QItemSelection as M50
import qualified Graphics.UI.Qtah.Generated.Core.QList.QModelIndex as M200
import qualified Graphics.UI.Qtah.Generated.Core.QModelIndex as M92
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QProcess as M106
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QVariant as M168
import qualified Graphics.UI.Qtah.Generated.Core.QVector.Int as M214
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QClipboard as M248
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import qualified Graphics.UI.Qtah.Generated.Gui.QPaintEvent as M308
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QWindow as M342
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractButton as M354
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractSlider as M364
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QAction as M368
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QDockWidget as M392
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsItem as M404
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QMdiSubWindow as M446
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QSystemTrayIcon as M486
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QTreeWidgetItem as M502
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "wrapper" callbackBoolVoid_new'newFunPtr :: (HoppyFC.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackBoolVoid" callbackBoolVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CBool -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackDirectionVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackDirectionVoid" callbackDirectionVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackDockWidgetAreaVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackDockWidgetAreaVoid" callbackDockWidgetAreaVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackDockWidgetAreasVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackDockWidgetAreasVoid" callbackDockWidgetAreasVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackDoubleVoid_new'newFunPtr :: (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackDoubleVoid" callbackDoubleVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackIntBoolVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackIntBoolVoid" callbackIntBoolVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackIntExitStatusVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackIntExitStatusVoid" callbackIntExitStatusVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackIntIntVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackIntIntVoid" callbackIntIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackIntQlonglongVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackIntQlonglongVoid" callbackIntQlonglongVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackIntVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackIntVoid" callbackIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackOrientationIntIntVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackOrientationIntIntVoid" callbackOrientationIntIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackOrientationVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackOrientationVoid" callbackOrientationVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackProcessErrorVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackProcessErrorVoid" callbackProcessErrorVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackProcessStateVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackProcessStateVoid" callbackProcessStateVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQAbstractButtonBoolVoid_new'newFunPtr :: (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQAbstractButtonBoolVoid" callbackPtrQAbstractButtonBoolVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQAbstractButtonVoid_new'newFunPtr :: (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQAbstractButtonVoid" callbackPtrQAbstractButtonVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQAbstractItemModelVoid_new'newFunPtr :: (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQAbstractItemModelVoid" callbackPtrQAbstractItemModelVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQActionVoid_new'newFunPtr :: (HoppyF.Ptr M368.QAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M368.QAction -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQActionVoid" callbackPtrQActionVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M368.QAction -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M368.QAction -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQGraphicsItemPtrQEventBool_new'newFunPtr :: (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
foreign import ccall "genpop__CallbackPtrQGraphicsItemPtrQEventBool" callbackPtrQGraphicsItemPtrQEventBool_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
foreign import ccall "wrapper" callbackPtrQMdiSubWindowVoid_new'newFunPtr :: (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQMdiSubWindowVoid" callbackPtrQMdiSubWindowVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQObjectPtrQEventBool_new'newFunPtr :: (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
foreign import ccall "genpop__CallbackPtrQObjectPtrQEventBool" callbackPtrQObjectPtrQEventBool_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
foreign import ccall "wrapper" callbackPtrQObjectVoid_new'newFunPtr :: (HoppyF.Ptr M94.QObject -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQObjectVoid" callbackPtrQObjectVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M94.QObject -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQPaintEventVoid_new'newFunPtr :: (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQPaintEventVoid" callbackPtrQPaintEventVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQTreeWidgetItemIntVoid_new'newFunPtr :: (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQTreeWidgetItemIntVoid" callbackPtrQTreeWidgetItemIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new'newFunPtr :: (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid" callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQTreeWidgetItemVoid_new'newFunPtr :: (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQTreeWidgetItemVoid" callbackPtrQTreeWidgetItemVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackPtrQWidgetPtrQWidgetVoid_new'newFunPtr :: (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackPtrQWidgetPtrQWidgetVoid" callbackPtrQWidgetPtrQWidgetVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQAbstractAnimationVoid_new'newFunPtr :: (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQAbstractAnimationVoid" callbackQAbstractAnimationVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQAbstractSliderActionVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQAbstractSliderActionVoid" callbackQAbstractSliderActionVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQClipboardModeVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQClipboardModeVoid" callbackQClipboardModeVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQDateVoid_new'newFunPtr :: (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQDateVoid" callbackQDateVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQDockWidgetFeaturesVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQDockWidgetFeaturesVoid" callbackQDockWidgetFeaturesVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQModelIndexIntIntQModelIndexIntVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQModelIndexIntIntQModelIndexIntVoid" callbackQModelIndexIntIntQModelIndexIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQModelIndexIntIntVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQModelIndexIntIntVoid" callbackQModelIndexIntIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQModelIndexQModelIndexQVectorIntVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQModelIndexQModelIndexQVectorIntVoid" callbackQModelIndexQModelIndexQVectorIntVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQModelIndexQModelIndexVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQModelIndexQModelIndexVoid" callbackQModelIndexQModelIndexVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQModelIndexVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQModelIndexVoid" callbackQModelIndexVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQPointVoid_new'newFunPtr :: (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQPointVoid" callbackQPointVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQSizeVoid_new'newFunPtr :: (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQSizeVoid" callbackQSizeVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQStringVoid_new'newFunPtr :: (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQStringVoid" callbackQStringVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQSystemTrayIconActivationReasonVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQSystemTrayIconActivationReasonVoid" callbackQSystemTrayIconActivationReasonVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQWindowVisibilityVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQWindowVisibilityVoid" callbackQWindowVisibilityVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQlonglongVoid_new'newFunPtr :: (HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyDI.Int64 -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQlonglongVoid" callbackQlonglongVoid_new'newCallback :: HoppyF.FunPtr (HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyDI.Int64 -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackQrealVoid_new'newFunPtr :: (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackQrealVoid" callbackQrealVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackRefConstQIconVoid_new'newFunPtr :: (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackRefConstQIconVoid" callbackRefConstQIconVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new'newFunPtr :: (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackRefConstQItemSelectionRefConstQItemSelectionVoid" callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackRefConstQListQModelIndexVoid_new'newFunPtr :: (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackRefConstQListQModelIndexVoid" callbackRefConstQListQModelIndexVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackRefConstQModelIndexVoid_new'newFunPtr :: (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackRefConstQModelIndexVoid" callbackRefConstQModelIndexVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackRefConstQVariantVoid_new'newFunPtr :: (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackRefConstQVariantVoid" callbackRefConstQVariantVoid_new'newCallback :: HoppyF.FunPtr (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackScreenOrientationVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackScreenOrientationVoid" callbackScreenOrientationVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackStateStateVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackStateStateVoid" callbackStateStateVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackToolBarAreasVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackToolBarAreasVoid" callbackToolBarAreasVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackToolButtonStyleVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackToolButtonStyleVoid" callbackToolButtonStyleVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackVoid_new'newFunPtr :: HoppyP.IO () -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
foreign import ccall "genpop__CallbackVoid" callbackVoid_new'newCallback :: HoppyF.FunPtr (HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyP.IO ()))
foreign import ccall "wrapper" callbackWindowModalityVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackWindowModalityVoid" callbackWindowModalityVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackWindowStateVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackWindowStateVoid" callbackWindowStateVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "wrapper" callbackWindowStatesWindowStatesVoid_new'newFunPtr :: (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
foreign import ccall "genpop__CallbackWindowStatesWindowStatesVoid" callbackWindowStatesWindowStatesVoid_new'newCallback :: HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.FunPtr (HoppyF.FunPtr (HoppyP.IO ()) -> HoppyP.IO ()) -> HoppyP.Bool -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))

callbackBoolVoid_newFunPtr :: (HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CBool -> HoppyP.IO ()))
callbackBoolVoid_newFunPtr f'hs = callbackBoolVoid_new'newFunPtr $ \arg'1 ->
  (
    (HoppyP.return . (/= 0))
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackBoolVoid_new :: (HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CBool -> HoppyP.IO ()))
callbackBoolVoid_new f'hs = do
  f'p <- callbackBoolVoid_newFunPtr f'hs
  callbackBoolVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackDirectionVoid_newFunPtr :: (M2.QAbstractAnimationDirection -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackDirectionVoid_newFunPtr f'hs = callbackDirectionVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackDirectionVoid_new :: (M2.QAbstractAnimationDirection -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackDirectionVoid_new f'hs = do
  f'p <- callbackDirectionVoid_newFunPtr f'hs
  callbackDirectionVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackDockWidgetAreaVoid_newFunPtr :: (M190.QtDockWidgetArea -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackDockWidgetAreaVoid_newFunPtr f'hs = callbackDockWidgetAreaVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackDockWidgetAreaVoid_new :: (M190.QtDockWidgetArea -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackDockWidgetAreaVoid_new f'hs = do
  f'p <- callbackDockWidgetAreaVoid_newFunPtr f'hs
  callbackDockWidgetAreaVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackDockWidgetAreasVoid_newFunPtr :: (M190.QtDockWidgetAreas -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackDockWidgetAreasVoid_newFunPtr f'hs = callbackDockWidgetAreasVoid_new'newFunPtr $ \arg'1 ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackDockWidgetAreasVoid_new :: (M190.QtDockWidgetAreas -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackDockWidgetAreasVoid_new f'hs = do
  f'p <- callbackDockWidgetAreasVoid_newFunPtr f'hs
  callbackDockWidgetAreasVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackDoubleVoid_newFunPtr :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()))
callbackDoubleVoid_newFunPtr f'hs = callbackDoubleVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackDoubleVoid_new :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()))
callbackDoubleVoid_new f'hs = do
  f'p <- callbackDoubleVoid_newFunPtr f'hs
  callbackDoubleVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackIntBoolVoid_newFunPtr :: (HoppyP.Int -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()))
callbackIntBoolVoid_newFunPtr f'hs = callbackIntBoolVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackIntBoolVoid_new :: (HoppyP.Int -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()))
callbackIntBoolVoid_new f'hs = do
  f'p <- callbackIntBoolVoid_newFunPtr f'hs
  callbackIntBoolVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackIntExitStatusVoid_newFunPtr :: (HoppyP.Int -> M106.QProcessExitStatus -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackIntExitStatusVoid_newFunPtr f'hs = callbackIntExitStatusVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackIntExitStatusVoid_new :: (HoppyP.Int -> M106.QProcessExitStatus -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackIntExitStatusVoid_new f'hs = do
  f'p <- callbackIntExitStatusVoid_newFunPtr f'hs
  callbackIntExitStatusVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackIntIntVoid_newFunPtr :: (HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackIntIntVoid_newFunPtr f'hs = callbackIntIntVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackIntIntVoid_new :: (HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackIntIntVoid_new f'hs = do
  f'p <- callbackIntIntVoid_newFunPtr f'hs
  callbackIntIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackIntQlonglongVoid_newFunPtr :: (HoppyP.Int -> HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()))
callbackIntQlonglongVoid_newFunPtr f'hs = callbackIntQlonglongVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  let arg'2' = arg'2 in
  (f'hs arg'1' arg'2')

callbackIntQlonglongVoid_new :: (HoppyP.Int -> HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyDI.Int64 -> HoppyP.IO ()))
callbackIntQlonglongVoid_new f'hs = do
  f'p <- callbackIntQlonglongVoid_newFunPtr f'hs
  callbackIntQlonglongVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackIntVoid_newFunPtr :: (HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackIntVoid_newFunPtr f'hs = callbackIntVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackIntVoid_new :: (HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackIntVoid_new f'hs = do
  f'p <- callbackIntVoid_newFunPtr f'hs
  callbackIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackOrientationIntIntVoid_newFunPtr :: (M190.QtOrientation -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackOrientationIntIntVoid_newFunPtr f'hs = callbackOrientationIntIntVoid_new'newFunPtr $ \arg'1 arg'2 arg'3 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (f'hs arg'1' arg'2' arg'3')

callbackOrientationIntIntVoid_new :: (M190.QtOrientation -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackOrientationIntIntVoid_new f'hs = do
  f'p <- callbackOrientationIntIntVoid_newFunPtr f'hs
  callbackOrientationIntIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackOrientationVoid_newFunPtr :: (M190.QtOrientation -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackOrientationVoid_newFunPtr f'hs = callbackOrientationVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackOrientationVoid_new :: (M190.QtOrientation -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackOrientationVoid_new f'hs = do
  f'p <- callbackOrientationVoid_newFunPtr f'hs
  callbackOrientationVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackProcessErrorVoid_newFunPtr :: (M106.QProcessProcessError -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackProcessErrorVoid_newFunPtr f'hs = callbackProcessErrorVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackProcessErrorVoid_new :: (M106.QProcessProcessError -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackProcessErrorVoid_new f'hs = do
  f'p <- callbackProcessErrorVoid_newFunPtr f'hs
  callbackProcessErrorVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackProcessStateVoid_newFunPtr :: (M106.QProcessProcessState -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackProcessStateVoid_newFunPtr f'hs = callbackProcessStateVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackProcessStateVoid_new :: (M106.QProcessProcessState -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackProcessStateVoid_new f'hs = do
  f'p <- callbackProcessStateVoid_newFunPtr f'hs
  callbackProcessStateVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQAbstractButtonBoolVoid_newFunPtr :: (M354.QAbstractButton -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()))
callbackPtrQAbstractButtonBoolVoid_newFunPtr f'hs = callbackPtrQAbstractButtonBoolVoid_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M354.QAbstractButton arg'1 in
  (
    (HoppyP.return . (/= 0))
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackPtrQAbstractButtonBoolVoid_new :: (M354.QAbstractButton -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CBool -> HoppyP.IO ()))
callbackPtrQAbstractButtonBoolVoid_new f'hs = do
  f'p <- callbackPtrQAbstractButtonBoolVoid_newFunPtr f'hs
  callbackPtrQAbstractButtonBoolVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQAbstractButtonVoid_newFunPtr :: (M354.QAbstractButton -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()))
callbackPtrQAbstractButtonVoid_newFunPtr f'hs = callbackPtrQAbstractButtonVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M354.QAbstractButton arg'1 in
  (f'hs arg'1')

callbackPtrQAbstractButtonVoid_new :: (M354.QAbstractButton -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()))
callbackPtrQAbstractButtonVoid_new f'hs = do
  f'p <- callbackPtrQAbstractButtonVoid_newFunPtr f'hs
  callbackPtrQAbstractButtonVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQAbstractItemModelVoid_newFunPtr :: (M4.QAbstractItemModel -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()))
callbackPtrQAbstractItemModelVoid_newFunPtr f'hs = callbackPtrQAbstractItemModelVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M4.QAbstractItemModel arg'1 in
  (f'hs arg'1')

callbackPtrQAbstractItemModelVoid_new :: (M4.QAbstractItemModel -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M4.QAbstractItemModel -> HoppyP.IO ()))
callbackPtrQAbstractItemModelVoid_new f'hs = do
  f'p <- callbackPtrQAbstractItemModelVoid_newFunPtr f'hs
  callbackPtrQAbstractItemModelVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQActionVoid_newFunPtr :: (M368.QAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M368.QAction -> HoppyP.IO ()))
callbackPtrQActionVoid_newFunPtr f'hs = callbackPtrQActionVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M368.QAction arg'1 in
  (f'hs arg'1')

callbackPtrQActionVoid_new :: (M368.QAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M368.QAction -> HoppyP.IO ()))
callbackPtrQActionVoid_new f'hs = do
  f'p <- callbackPtrQActionVoid_newFunPtr f'hs
  callbackPtrQActionVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQGraphicsItemPtrQEventBool_newFunPtr :: (M404.QGraphicsItem -> M34.QEvent -> HoppyP.IO HoppyP.Bool) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
callbackPtrQGraphicsItemPtrQEventBool_newFunPtr f'hs = callbackPtrQGraphicsItemPtrQEventBool_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M404.QGraphicsItem arg'1 in
  let arg'2' = M34.QEvent arg'2 in
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) =<<
  (f'hs arg'1' arg'2')

callbackPtrQGraphicsItemPtrQEventBool_new :: (M404.QGraphicsItem -> M34.QEvent -> HoppyP.IO HoppyP.Bool) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
callbackPtrQGraphicsItemPtrQEventBool_new f'hs = do
  f'p <- callbackPtrQGraphicsItemPtrQEventBool_newFunPtr f'hs
  callbackPtrQGraphicsItemPtrQEventBool_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQMdiSubWindowVoid_newFunPtr :: (M446.QMdiSubWindow -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()))
callbackPtrQMdiSubWindowVoid_newFunPtr f'hs = callbackPtrQMdiSubWindowVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M446.QMdiSubWindow arg'1 in
  (f'hs arg'1')

callbackPtrQMdiSubWindowVoid_new :: (M446.QMdiSubWindow -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M446.QMdiSubWindow -> HoppyP.IO ()))
callbackPtrQMdiSubWindowVoid_new f'hs = do
  f'p <- callbackPtrQMdiSubWindowVoid_newFunPtr f'hs
  callbackPtrQMdiSubWindowVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQObjectPtrQEventBool_newFunPtr :: (M94.QObject -> M34.QEvent -> HoppyP.IO HoppyP.Bool) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
callbackPtrQObjectPtrQEventBool_newFunPtr f'hs = callbackPtrQObjectPtrQEventBool_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M94.QObject arg'1 in
  let arg'2' = M34.QEvent arg'2 in
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) =<<
  (f'hs arg'1' arg'2')

callbackPtrQObjectPtrQEventBool_new :: (M94.QObject -> M34.QEvent -> HoppyP.IO HoppyP.Bool) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M94.QObject -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool))
callbackPtrQObjectPtrQEventBool_new f'hs = do
  f'p <- callbackPtrQObjectPtrQEventBool_newFunPtr f'hs
  callbackPtrQObjectPtrQEventBool_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQObjectVoid_newFunPtr :: (M94.QObject -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M94.QObject -> HoppyP.IO ()))
callbackPtrQObjectVoid_newFunPtr f'hs = callbackPtrQObjectVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M94.QObject arg'1 in
  (f'hs arg'1')

callbackPtrQObjectVoid_new :: (M94.QObject -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M94.QObject -> HoppyP.IO ()))
callbackPtrQObjectVoid_new f'hs = do
  f'p <- callbackPtrQObjectVoid_newFunPtr f'hs
  callbackPtrQObjectVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQPaintEventVoid_newFunPtr :: (M308.QPaintEvent -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()))
callbackPtrQPaintEventVoid_newFunPtr f'hs = callbackPtrQPaintEventVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M308.QPaintEvent arg'1 in
  (f'hs arg'1')

callbackPtrQPaintEventVoid_new :: (M308.QPaintEvent -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M308.QPaintEvent -> HoppyP.IO ()))
callbackPtrQPaintEventVoid_new f'hs = do
  f'p <- callbackPtrQPaintEventVoid_newFunPtr f'hs
  callbackPtrQPaintEventVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQTreeWidgetItemIntVoid_newFunPtr :: (M502.QTreeWidgetItem -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemIntVoid_newFunPtr f'hs = callbackPtrQTreeWidgetItemIntVoid_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M502.QTreeWidgetItem arg'1 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackPtrQTreeWidgetItemIntVoid_new :: (M502.QTreeWidgetItem -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemIntVoid_new f'hs = do
  f'p <- callbackPtrQTreeWidgetItemIntVoid_newFunPtr f'hs
  callbackPtrQTreeWidgetItemIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_newFunPtr :: (M502.QTreeWidgetItem -> M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_newFunPtr f'hs = callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M502.QTreeWidgetItem arg'1 in
  let arg'2' = M502.QTreeWidgetItem arg'2 in
  (f'hs arg'1' arg'2')

callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new :: (M502.QTreeWidgetItem -> M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new f'hs = do
  f'p <- callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_newFunPtr f'hs
  callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQTreeWidgetItemVoid_newFunPtr :: (M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemVoid_newFunPtr f'hs = callbackPtrQTreeWidgetItemVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M502.QTreeWidgetItem arg'1 in
  (f'hs arg'1')

callbackPtrQTreeWidgetItemVoid_new :: (M502.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M502.QTreeWidgetItem -> HoppyP.IO ()))
callbackPtrQTreeWidgetItemVoid_new f'hs = do
  f'p <- callbackPtrQTreeWidgetItemVoid_newFunPtr f'hs
  callbackPtrQTreeWidgetItemVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackPtrQWidgetPtrQWidgetVoid_newFunPtr :: (M506.QWidget -> M506.QWidget -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()))
callbackPtrQWidgetPtrQWidgetVoid_newFunPtr f'hs = callbackPtrQWidgetPtrQWidgetVoid_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M506.QWidget arg'1 in
  let arg'2' = M506.QWidget arg'2 in
  (f'hs arg'1' arg'2')

callbackPtrQWidgetPtrQWidgetVoid_new :: (M506.QWidget -> M506.QWidget -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M506.QWidget -> HoppyP.IO ()))
callbackPtrQWidgetPtrQWidgetVoid_new f'hs = do
  f'p <- callbackPtrQWidgetPtrQWidgetVoid_newFunPtr f'hs
  callbackPtrQWidgetPtrQWidgetVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQAbstractAnimationVoid_newFunPtr :: (M2.QAbstractAnimation -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()))
callbackQAbstractAnimationVoid_newFunPtr f'hs = callbackQAbstractAnimationVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M2.QAbstractAnimation arg'1 in
  (f'hs arg'1')

callbackQAbstractAnimationVoid_new :: (M2.QAbstractAnimation -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M2.QAbstractAnimation -> HoppyP.IO ()))
callbackQAbstractAnimationVoid_new f'hs = do
  f'p <- callbackQAbstractAnimationVoid_newFunPtr f'hs
  callbackQAbstractAnimationVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQAbstractSliderActionVoid_newFunPtr :: (M364.QAbstractSliderAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackQAbstractSliderActionVoid_newFunPtr f'hs = callbackQAbstractSliderActionVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQAbstractSliderActionVoid_new :: (M364.QAbstractSliderAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackQAbstractSliderActionVoid_new f'hs = do
  f'p <- callbackQAbstractSliderActionVoid_newFunPtr f'hs
  callbackQAbstractSliderActionVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQClipboardModeVoid_newFunPtr :: (M248.QClipboardMode -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackQClipboardModeVoid_newFunPtr f'hs = callbackQClipboardModeVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQClipboardModeVoid_new :: (M248.QClipboardMode -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackQClipboardModeVoid_new f'hs = do
  f'p <- callbackQClipboardModeVoid_newFunPtr f'hs
  callbackQClipboardModeVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQDateVoid_newFunPtr :: (M22.QDate -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()))
callbackQDateVoid_newFunPtr f'hs = callbackQDateVoid_new'newFunPtr $ \arg'1 ->
  HoppyFHR.decode (M22.QDateConst arg'1) >>= \arg'1' ->
  (f'hs arg'1')

callbackQDateVoid_new :: (M22.QDate -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M22.QDateConst -> HoppyP.IO ()))
callbackQDateVoid_new f'hs = do
  f'p <- callbackQDateVoid_newFunPtr f'hs
  callbackQDateVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQDockWidgetFeaturesVoid_newFunPtr :: (M392.QDockWidgetDockWidgetFeatures -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackQDockWidgetFeaturesVoid_newFunPtr f'hs = callbackQDockWidgetFeaturesVoid_new'newFunPtr $ \arg'1 ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQDockWidgetFeaturesVoid_new :: (M392.QDockWidgetDockWidgetFeatures -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackQDockWidgetFeaturesVoid_new f'hs = do
  f'p <- callbackQDockWidgetFeaturesVoid_newFunPtr f'hs
  callbackQDockWidgetFeaturesVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQModelIndexIntIntQModelIndexIntVoid_newFunPtr :: (M92.QModelIndex -> HoppyP.Int -> HoppyP.Int -> M92.QModelIndex -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()))
callbackQModelIndexIntIntQModelIndexIntVoid_newFunPtr f'hs = callbackQModelIndexIntIntQModelIndexIntVoid_new'newFunPtr $ \arg'1 arg'2 arg'3 arg'4 arg'5 ->
  HoppyFHR.decode (M92.QModelIndexConst arg'1) >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyFHR.decode (M92.QModelIndexConst arg'4) >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (f'hs arg'1' arg'2' arg'3' arg'4' arg'5')

callbackQModelIndexIntIntQModelIndexIntVoid_new :: (M92.QModelIndex -> HoppyP.Int -> HoppyP.Int -> M92.QModelIndex -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()))
callbackQModelIndexIntIntQModelIndexIntVoid_new f'hs = do
  f'p <- callbackQModelIndexIntIntQModelIndexIntVoid_newFunPtr f'hs
  callbackQModelIndexIntIntQModelIndexIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQModelIndexIntIntVoid_newFunPtr :: (M92.QModelIndex -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackQModelIndexIntIntVoid_newFunPtr f'hs = callbackQModelIndexIntIntVoid_new'newFunPtr $ \arg'1 arg'2 arg'3 ->
  HoppyFHR.decode (M92.QModelIndexConst arg'1) >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (f'hs arg'1' arg'2' arg'3')

callbackQModelIndexIntIntVoid_new :: (M92.QModelIndex -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackQModelIndexIntIntVoid_new f'hs = do
  f'p <- callbackQModelIndexIntIntVoid_newFunPtr f'hs
  callbackQModelIndexIntIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQModelIndexQModelIndexQVectorIntVoid_newFunPtr :: (M92.QModelIndex -> M92.QModelIndex -> M214.QVectorInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()))
callbackQModelIndexQModelIndexQVectorIntVoid_newFunPtr f'hs = callbackQModelIndexQModelIndexQVectorIntVoid_new'newFunPtr $ \arg'1 arg'2 arg'3 ->
  HoppyFHR.decode (M92.QModelIndexConst arg'1) >>= \arg'1' ->
  HoppyFHR.decode (M92.QModelIndexConst arg'2) >>= \arg'2' ->
  HoppyFHR.toGc (M214.QVectorInt arg'3) >>= \arg'3' ->
  (f'hs arg'1' arg'2' arg'3')

callbackQModelIndexQModelIndexQVectorIntVoid_new :: (M92.QModelIndex -> M92.QModelIndex -> M214.QVectorInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M214.QVectorInt -> HoppyP.IO ()))
callbackQModelIndexQModelIndexQVectorIntVoid_new f'hs = do
  f'p <- callbackQModelIndexQModelIndexQVectorIntVoid_newFunPtr f'hs
  callbackQModelIndexQModelIndexQVectorIntVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQModelIndexQModelIndexVoid_newFunPtr :: (M92.QModelIndex -> M92.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackQModelIndexQModelIndexVoid_newFunPtr f'hs = callbackQModelIndexQModelIndexVoid_new'newFunPtr $ \arg'1 arg'2 ->
  HoppyFHR.decode (M92.QModelIndexConst arg'1) >>= \arg'1' ->
  HoppyFHR.decode (M92.QModelIndexConst arg'2) >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackQModelIndexQModelIndexVoid_new :: (M92.QModelIndex -> M92.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackQModelIndexQModelIndexVoid_new f'hs = do
  f'p <- callbackQModelIndexQModelIndexVoid_newFunPtr f'hs
  callbackQModelIndexQModelIndexVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQModelIndexVoid_newFunPtr :: (M92.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackQModelIndexVoid_newFunPtr f'hs = callbackQModelIndexVoid_new'newFunPtr $ \arg'1 ->
  HoppyFHR.decode (M92.QModelIndexConst arg'1) >>= \arg'1' ->
  (f'hs arg'1')

callbackQModelIndexVoid_new :: (M92.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackQModelIndexVoid_new f'hs = do
  f'p <- callbackQModelIndexVoid_newFunPtr f'hs
  callbackQModelIndexVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQPointVoid_newFunPtr :: (HPoint.HPoint -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()))
callbackQPointVoid_newFunPtr f'hs = callbackQPointVoid_new'newFunPtr $ \arg'1 ->
  HoppyFHR.decode (M114.QPointConst arg'1) >>= \arg'1' ->
  (f'hs arg'1')

callbackQPointVoid_new :: (HPoint.HPoint -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()))
callbackQPointVoid_new f'hs = do
  f'p <- callbackQPointVoid_newFunPtr f'hs
  callbackQPointVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQSizeVoid_newFunPtr :: (HSize.HSize -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()))
callbackQSizeVoid_newFunPtr f'hs = callbackQSizeVoid_new'newFunPtr $ \arg'1 ->
  HoppyFHR.decode (M134.QSizeConst arg'1) >>= \arg'1' ->
  (f'hs arg'1')

callbackQSizeVoid_new :: (HSize.HSize -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()))
callbackQSizeVoid_new f'hs = do
  f'p <- callbackQSizeVoid_newFunPtr f'hs
  callbackQSizeVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQStringVoid_newFunPtr :: (QtahP.String -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()))
callbackQStringVoid_newFunPtr f'hs = callbackQStringVoid_new'newFunPtr $ \arg'1 ->
  HoppyFHR.decode (M142.QStringConst arg'1) >>= \arg'1' ->
  (f'hs arg'1')

callbackQStringVoid_new :: (QtahP.String -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()))
callbackQStringVoid_new f'hs = do
  f'p <- callbackQStringVoid_newFunPtr f'hs
  callbackQStringVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQSystemTrayIconActivationReasonVoid_newFunPtr :: (M486.QSystemTrayIconActivationReason -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackQSystemTrayIconActivationReasonVoid_newFunPtr f'hs = callbackQSystemTrayIconActivationReasonVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQSystemTrayIconActivationReasonVoid_new :: (M486.QSystemTrayIconActivationReason -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackQSystemTrayIconActivationReasonVoid_new f'hs = do
  f'p <- callbackQSystemTrayIconActivationReasonVoid_newFunPtr f'hs
  callbackQSystemTrayIconActivationReasonVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQWindowVisibilityVoid_newFunPtr :: (M342.QWindowVisibility -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackQWindowVisibilityVoid_newFunPtr f'hs = callbackQWindowVisibilityVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQWindowVisibilityVoid_new :: (M342.QWindowVisibility -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackQWindowVisibilityVoid_new f'hs = do
  f'p <- callbackQWindowVisibilityVoid_newFunPtr f'hs
  callbackQWindowVisibilityVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQlonglongVoid_newFunPtr :: (HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyDI.Int64 -> HoppyP.IO ()))
callbackQlonglongVoid_newFunPtr f'hs = callbackQlonglongVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = arg'1 in
  (f'hs arg'1')

callbackQlonglongVoid_new :: (HoppyDI.Int64 -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyDI.Int64 -> HoppyP.IO ()))
callbackQlonglongVoid_new f'hs = do
  f'p <- callbackQlonglongVoid_newFunPtr f'hs
  callbackQlonglongVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackQrealVoid_newFunPtr :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CDouble -> HoppyP.IO ()))
callbackQrealVoid_newFunPtr f'hs = callbackQrealVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackQrealVoid_new :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()))
callbackQrealVoid_new f'hs = do
  f'p <- callbackQrealVoid_newFunPtr f'hs
  callbackQrealVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackRefConstQIconVoid_newFunPtr :: (M288.QIconConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()))
callbackRefConstQIconVoid_newFunPtr f'hs = callbackRefConstQIconVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M288.QIconConst arg'1 in
  (f'hs arg'1')

callbackRefConstQIconVoid_new :: (M288.QIconConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()))
callbackRefConstQIconVoid_new f'hs = do
  f'p <- callbackRefConstQIconVoid_newFunPtr f'hs
  callbackRefConstQIconVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackRefConstQItemSelectionRefConstQItemSelectionVoid_newFunPtr :: (M50.QItemSelectionConst -> M50.QItemSelectionConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()))
callbackRefConstQItemSelectionRefConstQItemSelectionVoid_newFunPtr f'hs = callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new'newFunPtr $ \arg'1 arg'2 ->
  let arg'1' = M50.QItemSelectionConst arg'1 in
  let arg'2' = M50.QItemSelectionConst arg'2 in
  (f'hs arg'1' arg'2')

callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new :: (M50.QItemSelectionConst -> M50.QItemSelectionConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M50.QItemSelectionConst -> HoppyF.Ptr M50.QItemSelectionConst -> HoppyP.IO ()))
callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new f'hs = do
  f'p <- callbackRefConstQItemSelectionRefConstQItemSelectionVoid_newFunPtr f'hs
  callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackRefConstQListQModelIndexVoid_newFunPtr :: (M200.QListQModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()))
callbackRefConstQListQModelIndexVoid_newFunPtr f'hs = callbackRefConstQListQModelIndexVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M200.QListQModelIndexConst arg'1 in
  (f'hs arg'1')

callbackRefConstQListQModelIndexVoid_new :: (M200.QListQModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M200.QListQModelIndexConst -> HoppyP.IO ()))
callbackRefConstQListQModelIndexVoid_new f'hs = do
  f'p <- callbackRefConstQListQModelIndexVoid_newFunPtr f'hs
  callbackRefConstQListQModelIndexVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackRefConstQModelIndexVoid_newFunPtr :: (M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackRefConstQModelIndexVoid_newFunPtr f'hs = callbackRefConstQModelIndexVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M92.QModelIndexConst arg'1 in
  (f'hs arg'1')

callbackRefConstQModelIndexVoid_new :: (M92.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO ()))
callbackRefConstQModelIndexVoid_new f'hs = do
  f'p <- callbackRefConstQModelIndexVoid_newFunPtr f'hs
  callbackRefConstQModelIndexVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackRefConstQVariantVoid_newFunPtr :: (M168.QVariantConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()))
callbackRefConstQVariantVoid_newFunPtr f'hs = callbackRefConstQVariantVoid_new'newFunPtr $ \arg'1 ->
  let arg'1' = M168.QVariantConst arg'1 in
  (f'hs arg'1')

callbackRefConstQVariantVoid_new :: (M168.QVariantConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()))
callbackRefConstQVariantVoid_new f'hs = do
  f'p <- callbackRefConstQVariantVoid_newFunPtr f'hs
  callbackRefConstQVariantVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackScreenOrientationVoid_newFunPtr :: (M190.QtScreenOrientation -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackScreenOrientationVoid_newFunPtr f'hs = callbackScreenOrientationVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackScreenOrientationVoid_new :: (M190.QtScreenOrientation -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackScreenOrientationVoid_new f'hs = do
  f'p <- callbackScreenOrientationVoid_newFunPtr f'hs
  callbackScreenOrientationVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackStateStateVoid_newFunPtr :: (M2.QAbstractAnimationState -> M2.QAbstractAnimationState -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackStateStateVoid_newFunPtr f'hs = callbackStateStateVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackStateStateVoid_new :: (M2.QAbstractAnimationState -> M2.QAbstractAnimationState -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackStateStateVoid_new f'hs = do
  f'p <- callbackStateStateVoid_newFunPtr f'hs
  callbackStateStateVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackToolBarAreasVoid_newFunPtr :: (M190.QtToolBarAreas -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackToolBarAreasVoid_newFunPtr f'hs = callbackToolBarAreasVoid_new'newFunPtr $ \arg'1 ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackToolBarAreasVoid_new :: (M190.QtToolBarAreas -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackToolBarAreasVoid_new f'hs = do
  f'p <- callbackToolBarAreasVoid_newFunPtr f'hs
  callbackToolBarAreasVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackToolButtonStyleVoid_newFunPtr :: (M190.QtToolButtonStyle -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackToolButtonStyleVoid_newFunPtr f'hs = callbackToolButtonStyleVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackToolButtonStyleVoid_new :: (M190.QtToolButtonStyle -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackToolButtonStyleVoid_new f'hs = do
  f'p <- callbackToolButtonStyleVoid_newFunPtr f'hs
  callbackToolButtonStyleVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackVoid_newFunPtr :: HoppyP.IO () -> HoppyP.IO (HoppyF.FunPtr (HoppyP.IO ()))
callbackVoid_newFunPtr f'hs = callbackVoid_new'newFunPtr $
  (f'hs)

callbackVoid_new :: HoppyP.IO () -> HoppyP.IO (HoppyFHR.CCallback (HoppyP.IO ()))
callbackVoid_new f'hs = do
  f'p <- callbackVoid_newFunPtr f'hs
  callbackVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackWindowModalityVoid_newFunPtr :: (M190.QtWindowModality -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowModalityVoid_newFunPtr f'hs = callbackWindowModalityVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackWindowModalityVoid_new :: (M190.QtWindowModality -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowModalityVoid_new f'hs = do
  f'p <- callbackWindowModalityVoid_newFunPtr f'hs
  callbackWindowModalityVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackWindowStateVoid_newFunPtr :: (M190.QtWindowState -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowStateVoid_newFunPtr f'hs = callbackWindowStateVoid_new'newFunPtr $ \arg'1 ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) arg'1 >>= \arg'1' ->
  (f'hs arg'1')

callbackWindowStateVoid_new :: (M190.QtWindowState -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowStateVoid_new f'hs = do
  f'p <- callbackWindowStateVoid_newFunPtr f'hs
  callbackWindowStateVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False

callbackWindowStatesWindowStatesVoid_newFunPtr :: (M190.QtWindowStates -> M190.QtWindowStates -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.FunPtr (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowStatesWindowStatesVoid_newFunPtr f'hs = callbackWindowStatesWindowStatesVoid_new'newFunPtr $ \arg'1 arg'2 ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) arg'1 >>= \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) arg'2 >>= \arg'2' ->
  (f'hs arg'1' arg'2')

callbackWindowStatesWindowStatesVoid_new :: (M190.QtWindowStates -> M190.QtWindowStates -> HoppyP.IO ()) -> HoppyP.IO (HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()))
callbackWindowStatesWindowStatesVoid_new f'hs = do
  f'p <- callbackWindowStatesWindowStatesVoid_newFunPtr f'hs
  callbackWindowStatesWindowStatesVoid_new'newCallback f'p HoppyFHR.freeHaskellFunPtrFunPtr HoppyP.False