{-# LANGUAGE FlexibleContexts, FlexibleInstances, ForeignFunctionInterface, GeneralizedNewtypeDeriving, MonoLocalBinds, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
module Graphics.UI.Qtah.Internal.Listener (
castListenerToQObject,
castQObjectToListener,
castListenerBoolToQObject,
castQObjectToListenerBool,
castListenerDockWidgetAreaToQObject,
castQObjectToListenerDockWidgetArea,
castListenerDockWidgetAreasToQObject,
castQObjectToListenerDockWidgetAreas,
castListenerDoubleToQObject,
castQObjectToListenerDouble,
castListenerIntToQObject,
castQObjectToListenerInt,
castListenerIntBoolToQObject,
castQObjectToListenerIntBool,
castListenerIntIntToQObject,
castQObjectToListenerIntInt,
castListenerOrientationToQObject,
castQObjectToListenerOrientation,
castListenerPtrQAbstractButtonToQObject,
castQObjectToListenerPtrQAbstractButton,
castListenerPtrQAbstractButtonBoolToQObject,
castQObjectToListenerPtrQAbstractButtonBool,
castListenerPtrQAbstractItemModelToQObject,
castQObjectToListenerPtrQAbstractItemModel,
castListenerPtrQActionToQObject,
castQObjectToListenerPtrQAction,
castListenerPtrQObjectToQObject,
castQObjectToListenerPtrQObject,
castListenerPtrQTreeWidgetItemToQObject,
castQObjectToListenerPtrQTreeWidgetItem,
castListenerPtrQTreeWidgetItemIntToQObject,
castQObjectToListenerPtrQTreeWidgetItemInt,
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject,
castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem,
castListenerPtrQWidgetPtrQWidgetToQObject,
castQObjectToListenerPtrQWidgetPtrQWidget,
castListenerQAbstractSliderActionToQObject,
castQObjectToListenerQAbstractSliderAction,
castListenerQClipboardModeToQObject,
castQObjectToListenerQClipboardMode,
castListenerQDateToQObject,
castQObjectToListenerQDate,
castListenerQDockWidgetFeaturesToQObject,
castQObjectToListenerQDockWidgetFeatures,
castListenerQModelIndexToQObject,
castQObjectToListenerQModelIndex,
castListenerQModelIndexIntIntToQObject,
castQObjectToListenerQModelIndexIntInt,
castListenerQModelIndexIntIntQModelIndexIntToQObject,
castQObjectToListenerQModelIndexIntIntQModelIndexInt,
castListenerQModelIndexQModelIndexToQObject,
castQObjectToListenerQModelIndexQModelIndex,
castListenerQModelIndexQModelIndexQVectorIntToQObject,
castQObjectToListenerQModelIndexQModelIndexQVectorInt,
castListenerQPointToQObject,
castQObjectToListenerQPoint,
castListenerQSizeToQObject,
castQObjectToListenerQSize,
castListenerQStringToQObject,
castQObjectToListenerQString,
castListenerQSystemTrayIconActivationReasonToQObject,
castQObjectToListenerQSystemTrayIconActivationReason,
castListenerQWindowVisibilityToQObject,
castQObjectToListenerQWindowVisibility,
castListenerQrealToQObject,
castQObjectToListenerQreal,
castListenerRefConstQIconToQObject,
castQObjectToListenerRefConstQIcon,
castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject,
castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection,
castListenerScreenOrientationToQObject,
castQObjectToListenerScreenOrientation,
castListenerToolBarAreasToQObject,
castQObjectToListenerToolBarAreas,
castListenerToolButtonStyleToQObject,
castQObjectToListenerToolButtonStyle,
castListenerWindowModalityToQObject,
castQObjectToListenerWindowModality,
castListenerWindowStateToQObject,
castQObjectToListenerWindowState,
ListenerValue (..),
ListenerConstPtr (..),
ListenerPtr (..),
listener_connectListener,
ListenerConst (..),
castListenerToConst,
Listener (..),
castListenerToNonconst,
listener_new,
listener_newWithParent,
ListenerSuper (..),
ListenerSuperConst (..),
ListenerBoolValue (..),
ListenerBoolConstPtr (..),
ListenerBoolPtr (..),
listenerBool_connectListener,
ListenerBoolConst (..),
castListenerBoolToConst,
ListenerBool (..),
castListenerBoolToNonconst,
listenerBool_new,
listenerBool_newWithParent,
ListenerBoolSuper (..),
ListenerBoolSuperConst (..),
ListenerDockWidgetAreaValue (..),
ListenerDockWidgetAreaConstPtr (..),
ListenerDockWidgetAreaPtr (..),
listenerDockWidgetArea_connectListener,
ListenerDockWidgetAreaConst (..),
castListenerDockWidgetAreaToConst,
ListenerDockWidgetArea (..),
castListenerDockWidgetAreaToNonconst,
listenerDockWidgetArea_new,
listenerDockWidgetArea_newWithParent,
ListenerDockWidgetAreaSuper (..),
ListenerDockWidgetAreaSuperConst (..),
ListenerDockWidgetAreasValue (..),
ListenerDockWidgetAreasConstPtr (..),
ListenerDockWidgetAreasPtr (..),
listenerDockWidgetAreas_connectListener,
ListenerDockWidgetAreasConst (..),
castListenerDockWidgetAreasToConst,
ListenerDockWidgetAreas (..),
castListenerDockWidgetAreasToNonconst,
listenerDockWidgetAreas_new,
listenerDockWidgetAreas_newWithParent,
ListenerDockWidgetAreasSuper (..),
ListenerDockWidgetAreasSuperConst (..),
ListenerDoubleValue (..),
ListenerDoubleConstPtr (..),
ListenerDoublePtr (..),
listenerDouble_connectListener,
ListenerDoubleConst (..),
castListenerDoubleToConst,
ListenerDouble (..),
castListenerDoubleToNonconst,
listenerDouble_new,
listenerDouble_newWithParent,
ListenerDoubleSuper (..),
ListenerDoubleSuperConst (..),
ListenerIntValue (..),
ListenerIntConstPtr (..),
ListenerIntPtr (..),
listenerInt_connectListener,
ListenerIntConst (..),
castListenerIntToConst,
ListenerInt (..),
castListenerIntToNonconst,
listenerInt_new,
listenerInt_newWithParent,
ListenerIntSuper (..),
ListenerIntSuperConst (..),
ListenerIntBoolValue (..),
ListenerIntBoolConstPtr (..),
ListenerIntBoolPtr (..),
listenerIntBool_connectListener,
ListenerIntBoolConst (..),
castListenerIntBoolToConst,
ListenerIntBool (..),
castListenerIntBoolToNonconst,
listenerIntBool_new,
listenerIntBool_newWithParent,
ListenerIntBoolSuper (..),
ListenerIntBoolSuperConst (..),
ListenerIntIntValue (..),
ListenerIntIntConstPtr (..),
ListenerIntIntPtr (..),
listenerIntInt_connectListener,
ListenerIntIntConst (..),
castListenerIntIntToConst,
ListenerIntInt (..),
castListenerIntIntToNonconst,
listenerIntInt_new,
listenerIntInt_newWithParent,
ListenerIntIntSuper (..),
ListenerIntIntSuperConst (..),
ListenerOrientationValue (..),
ListenerOrientationConstPtr (..),
ListenerOrientationPtr (..),
listenerOrientation_connectListener,
ListenerOrientationConst (..),
castListenerOrientationToConst,
ListenerOrientation (..),
castListenerOrientationToNonconst,
listenerOrientation_new,
listenerOrientation_newWithParent,
ListenerOrientationSuper (..),
ListenerOrientationSuperConst (..),
ListenerPtrQAbstractButtonValue (..),
ListenerPtrQAbstractButtonConstPtr (..),
ListenerPtrQAbstractButtonPtr (..),
listenerPtrQAbstractButton_connectListener,
ListenerPtrQAbstractButtonConst (..),
castListenerPtrQAbstractButtonToConst,
ListenerPtrQAbstractButton (..),
castListenerPtrQAbstractButtonToNonconst,
listenerPtrQAbstractButton_new,
listenerPtrQAbstractButton_newWithParent,
ListenerPtrQAbstractButtonSuper (..),
ListenerPtrQAbstractButtonSuperConst (..),
ListenerPtrQAbstractButtonBoolValue (..),
ListenerPtrQAbstractButtonBoolConstPtr (..),
ListenerPtrQAbstractButtonBoolPtr (..),
listenerPtrQAbstractButtonBool_connectListener,
ListenerPtrQAbstractButtonBoolConst (..),
castListenerPtrQAbstractButtonBoolToConst,
ListenerPtrQAbstractButtonBool (..),
castListenerPtrQAbstractButtonBoolToNonconst,
listenerPtrQAbstractButtonBool_new,
listenerPtrQAbstractButtonBool_newWithParent,
ListenerPtrQAbstractButtonBoolSuper (..),
ListenerPtrQAbstractButtonBoolSuperConst (..),
ListenerPtrQAbstractItemModelValue (..),
ListenerPtrQAbstractItemModelConstPtr (..),
ListenerPtrQAbstractItemModelPtr (..),
listenerPtrQAbstractItemModel_connectListener,
ListenerPtrQAbstractItemModelConst (..),
castListenerPtrQAbstractItemModelToConst,
ListenerPtrQAbstractItemModel (..),
castListenerPtrQAbstractItemModelToNonconst,
listenerPtrQAbstractItemModel_new,
listenerPtrQAbstractItemModel_newWithParent,
ListenerPtrQAbstractItemModelSuper (..),
ListenerPtrQAbstractItemModelSuperConst (..),
ListenerPtrQActionValue (..),
ListenerPtrQActionConstPtr (..),
ListenerPtrQActionPtr (..),
listenerPtrQAction_connectListener,
ListenerPtrQActionConst (..),
castListenerPtrQActionToConst,
ListenerPtrQAction (..),
castListenerPtrQActionToNonconst,
listenerPtrQAction_new,
listenerPtrQAction_newWithParent,
ListenerPtrQActionSuper (..),
ListenerPtrQActionSuperConst (..),
ListenerPtrQObjectValue (..),
ListenerPtrQObjectConstPtr (..),
ListenerPtrQObjectPtr (..),
listenerPtrQObject_connectListener,
ListenerPtrQObjectConst (..),
castListenerPtrQObjectToConst,
ListenerPtrQObject (..),
castListenerPtrQObjectToNonconst,
listenerPtrQObject_new,
listenerPtrQObject_newWithParent,
ListenerPtrQObjectSuper (..),
ListenerPtrQObjectSuperConst (..),
ListenerPtrQTreeWidgetItemValue (..),
ListenerPtrQTreeWidgetItemConstPtr (..),
ListenerPtrQTreeWidgetItemPtr (..),
listenerPtrQTreeWidgetItem_connectListener,
ListenerPtrQTreeWidgetItemConst (..),
castListenerPtrQTreeWidgetItemToConst,
ListenerPtrQTreeWidgetItem (..),
castListenerPtrQTreeWidgetItemToNonconst,
listenerPtrQTreeWidgetItem_new,
listenerPtrQTreeWidgetItem_newWithParent,
ListenerPtrQTreeWidgetItemSuper (..),
ListenerPtrQTreeWidgetItemSuperConst (..),
ListenerPtrQTreeWidgetItemIntValue (..),
ListenerPtrQTreeWidgetItemIntConstPtr (..),
ListenerPtrQTreeWidgetItemIntPtr (..),
listenerPtrQTreeWidgetItemInt_connectListener,
ListenerPtrQTreeWidgetItemIntConst (..),
castListenerPtrQTreeWidgetItemIntToConst,
ListenerPtrQTreeWidgetItemInt (..),
castListenerPtrQTreeWidgetItemIntToNonconst,
listenerPtrQTreeWidgetItemInt_new,
listenerPtrQTreeWidgetItemInt_newWithParent,
ListenerPtrQTreeWidgetItemIntSuper (..),
ListenerPtrQTreeWidgetItemIntSuperConst (..),
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemValue (..),
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr (..),
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr (..),
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener,
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst (..),
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToConst,
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem (..),
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToNonconst,
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new,
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent,
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuper (..),
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuperConst (..),
ListenerPtrQWidgetPtrQWidgetValue (..),
ListenerPtrQWidgetPtrQWidgetConstPtr (..),
ListenerPtrQWidgetPtrQWidgetPtr (..),
listenerPtrQWidgetPtrQWidget_connectListener,
ListenerPtrQWidgetPtrQWidgetConst (..),
castListenerPtrQWidgetPtrQWidgetToConst,
ListenerPtrQWidgetPtrQWidget (..),
castListenerPtrQWidgetPtrQWidgetToNonconst,
listenerPtrQWidgetPtrQWidget_new,
listenerPtrQWidgetPtrQWidget_newWithParent,
ListenerPtrQWidgetPtrQWidgetSuper (..),
ListenerPtrQWidgetPtrQWidgetSuperConst (..),
ListenerQAbstractSliderActionValue (..),
ListenerQAbstractSliderActionConstPtr (..),
ListenerQAbstractSliderActionPtr (..),
listenerQAbstractSliderAction_connectListener,
ListenerQAbstractSliderActionConst (..),
castListenerQAbstractSliderActionToConst,
ListenerQAbstractSliderAction (..),
castListenerQAbstractSliderActionToNonconst,
listenerQAbstractSliderAction_new,
listenerQAbstractSliderAction_newWithParent,
ListenerQAbstractSliderActionSuper (..),
ListenerQAbstractSliderActionSuperConst (..),
ListenerQClipboardModeValue (..),
ListenerQClipboardModeConstPtr (..),
ListenerQClipboardModePtr (..),
listenerQClipboardMode_connectListener,
ListenerQClipboardModeConst (..),
castListenerQClipboardModeToConst,
ListenerQClipboardMode (..),
castListenerQClipboardModeToNonconst,
listenerQClipboardMode_new,
listenerQClipboardMode_newWithParent,
ListenerQClipboardModeSuper (..),
ListenerQClipboardModeSuperConst (..),
ListenerQDateValue (..),
ListenerQDateConstPtr (..),
ListenerQDatePtr (..),
listenerQDate_connectListener,
ListenerQDateConst (..),
castListenerQDateToConst,
ListenerQDate (..),
castListenerQDateToNonconst,
listenerQDate_new,
listenerQDate_newWithParent,
ListenerQDateSuper (..),
ListenerQDateSuperConst (..),
ListenerQDockWidgetFeaturesValue (..),
ListenerQDockWidgetFeaturesConstPtr (..),
ListenerQDockWidgetFeaturesPtr (..),
listenerQDockWidgetFeatures_connectListener,
ListenerQDockWidgetFeaturesConst (..),
castListenerQDockWidgetFeaturesToConst,
ListenerQDockWidgetFeatures (..),
castListenerQDockWidgetFeaturesToNonconst,
listenerQDockWidgetFeatures_new,
listenerQDockWidgetFeatures_newWithParent,
ListenerQDockWidgetFeaturesSuper (..),
ListenerQDockWidgetFeaturesSuperConst (..),
ListenerQModelIndexValue (..),
ListenerQModelIndexConstPtr (..),
ListenerQModelIndexPtr (..),
listenerQModelIndex_connectListener,
ListenerQModelIndexConst (..),
castListenerQModelIndexToConst,
ListenerQModelIndex (..),
castListenerQModelIndexToNonconst,
listenerQModelIndex_new,
listenerQModelIndex_newWithParent,
ListenerQModelIndexSuper (..),
ListenerQModelIndexSuperConst (..),
ListenerQModelIndexIntIntValue (..),
ListenerQModelIndexIntIntConstPtr (..),
ListenerQModelIndexIntIntPtr (..),
listenerQModelIndexIntInt_connectListener,
ListenerQModelIndexIntIntConst (..),
castListenerQModelIndexIntIntToConst,
ListenerQModelIndexIntInt (..),
castListenerQModelIndexIntIntToNonconst,
listenerQModelIndexIntInt_new,
listenerQModelIndexIntInt_newWithParent,
ListenerQModelIndexIntIntSuper (..),
ListenerQModelIndexIntIntSuperConst (..),
ListenerQModelIndexIntIntQModelIndexIntValue (..),
ListenerQModelIndexIntIntQModelIndexIntConstPtr (..),
ListenerQModelIndexIntIntQModelIndexIntPtr (..),
listenerQModelIndexIntIntQModelIndexInt_connectListener,
ListenerQModelIndexIntIntQModelIndexIntConst (..),
castListenerQModelIndexIntIntQModelIndexIntToConst,
ListenerQModelIndexIntIntQModelIndexInt (..),
castListenerQModelIndexIntIntQModelIndexIntToNonconst,
listenerQModelIndexIntIntQModelIndexInt_new,
listenerQModelIndexIntIntQModelIndexInt_newWithParent,
ListenerQModelIndexIntIntQModelIndexIntSuper (..),
ListenerQModelIndexIntIntQModelIndexIntSuperConst (..),
ListenerQModelIndexQModelIndexValue (..),
ListenerQModelIndexQModelIndexConstPtr (..),
ListenerQModelIndexQModelIndexPtr (..),
listenerQModelIndexQModelIndex_connectListener,
ListenerQModelIndexQModelIndexConst (..),
castListenerQModelIndexQModelIndexToConst,
ListenerQModelIndexQModelIndex (..),
castListenerQModelIndexQModelIndexToNonconst,
listenerQModelIndexQModelIndex_new,
listenerQModelIndexQModelIndex_newWithParent,
ListenerQModelIndexQModelIndexSuper (..),
ListenerQModelIndexQModelIndexSuperConst (..),
ListenerQModelIndexQModelIndexQVectorIntValue (..),
ListenerQModelIndexQModelIndexQVectorIntConstPtr (..),
ListenerQModelIndexQModelIndexQVectorIntPtr (..),
listenerQModelIndexQModelIndexQVectorInt_connectListener,
ListenerQModelIndexQModelIndexQVectorIntConst (..),
castListenerQModelIndexQModelIndexQVectorIntToConst,
ListenerQModelIndexQModelIndexQVectorInt (..),
castListenerQModelIndexQModelIndexQVectorIntToNonconst,
listenerQModelIndexQModelIndexQVectorInt_new,
listenerQModelIndexQModelIndexQVectorInt_newWithParent,
ListenerQModelIndexQModelIndexQVectorIntSuper (..),
ListenerQModelIndexQModelIndexQVectorIntSuperConst (..),
ListenerQPointValue (..),
ListenerQPointConstPtr (..),
ListenerQPointPtr (..),
listenerQPoint_connectListener,
ListenerQPointConst (..),
castListenerQPointToConst,
ListenerQPoint (..),
castListenerQPointToNonconst,
listenerQPoint_new,
listenerQPoint_newWithParent,
ListenerQPointSuper (..),
ListenerQPointSuperConst (..),
ListenerQSizeValue (..),
ListenerQSizeConstPtr (..),
ListenerQSizePtr (..),
listenerQSize_connectListener,
ListenerQSizeConst (..),
castListenerQSizeToConst,
ListenerQSize (..),
castListenerQSizeToNonconst,
listenerQSize_new,
listenerQSize_newWithParent,
ListenerQSizeSuper (..),
ListenerQSizeSuperConst (..),
ListenerQStringValue (..),
ListenerQStringConstPtr (..),
ListenerQStringPtr (..),
listenerQString_connectListener,
ListenerQStringConst (..),
castListenerQStringToConst,
ListenerQString (..),
castListenerQStringToNonconst,
listenerQString_new,
listenerQString_newWithParent,
ListenerQStringSuper (..),
ListenerQStringSuperConst (..),
ListenerQSystemTrayIconActivationReasonValue (..),
ListenerQSystemTrayIconActivationReasonConstPtr (..),
ListenerQSystemTrayIconActivationReasonPtr (..),
listenerQSystemTrayIconActivationReason_connectListener,
ListenerQSystemTrayIconActivationReasonConst (..),
castListenerQSystemTrayIconActivationReasonToConst,
ListenerQSystemTrayIconActivationReason (..),
castListenerQSystemTrayIconActivationReasonToNonconst,
listenerQSystemTrayIconActivationReason_new,
listenerQSystemTrayIconActivationReason_newWithParent,
ListenerQSystemTrayIconActivationReasonSuper (..),
ListenerQSystemTrayIconActivationReasonSuperConst (..),
ListenerQWindowVisibilityValue (..),
ListenerQWindowVisibilityConstPtr (..),
ListenerQWindowVisibilityPtr (..),
listenerQWindowVisibility_connectListener,
ListenerQWindowVisibilityConst (..),
castListenerQWindowVisibilityToConst,
ListenerQWindowVisibility (..),
castListenerQWindowVisibilityToNonconst,
listenerQWindowVisibility_new,
listenerQWindowVisibility_newWithParent,
ListenerQWindowVisibilitySuper (..),
ListenerQWindowVisibilitySuperConst (..),
ListenerQrealValue (..),
ListenerQrealConstPtr (..),
ListenerQrealPtr (..),
listenerQreal_connectListener,
ListenerQrealConst (..),
castListenerQrealToConst,
ListenerQreal (..),
castListenerQrealToNonconst,
listenerQreal_new,
listenerQreal_newWithParent,
ListenerQrealSuper (..),
ListenerQrealSuperConst (..),
ListenerRefConstQIconValue (..),
ListenerRefConstQIconConstPtr (..),
ListenerRefConstQIconPtr (..),
listenerRefConstQIcon_connectListener,
ListenerRefConstQIconConst (..),
castListenerRefConstQIconToConst,
ListenerRefConstQIcon (..),
castListenerRefConstQIconToNonconst,
listenerRefConstQIcon_new,
listenerRefConstQIcon_newWithParent,
ListenerRefConstQIconSuper (..),
ListenerRefConstQIconSuperConst (..),
ListenerRefConstQItemSelectionRefConstQItemSelectionValue (..),
ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr (..),
ListenerRefConstQItemSelectionRefConstQItemSelectionPtr (..),
listenerRefConstQItemSelectionRefConstQItemSelection_connectListener,
ListenerRefConstQItemSelectionRefConstQItemSelectionConst (..),
castListenerRefConstQItemSelectionRefConstQItemSelectionToConst,
ListenerRefConstQItemSelectionRefConstQItemSelection (..),
castListenerRefConstQItemSelectionRefConstQItemSelectionToNonconst,
listenerRefConstQItemSelectionRefConstQItemSelection_new,
listenerRefConstQItemSelectionRefConstQItemSelection_newWithParent,
ListenerRefConstQItemSelectionRefConstQItemSelectionSuper (..),
ListenerRefConstQItemSelectionRefConstQItemSelectionSuperConst (..),
ListenerScreenOrientationValue (..),
ListenerScreenOrientationConstPtr (..),
ListenerScreenOrientationPtr (..),
listenerScreenOrientation_connectListener,
ListenerScreenOrientationConst (..),
castListenerScreenOrientationToConst,
ListenerScreenOrientation (..),
castListenerScreenOrientationToNonconst,
listenerScreenOrientation_new,
listenerScreenOrientation_newWithParent,
ListenerScreenOrientationSuper (..),
ListenerScreenOrientationSuperConst (..),
ListenerToolBarAreasValue (..),
ListenerToolBarAreasConstPtr (..),
ListenerToolBarAreasPtr (..),
listenerToolBarAreas_connectListener,
ListenerToolBarAreasConst (..),
castListenerToolBarAreasToConst,
ListenerToolBarAreas (..),
castListenerToolBarAreasToNonconst,
listenerToolBarAreas_new,
listenerToolBarAreas_newWithParent,
ListenerToolBarAreasSuper (..),
ListenerToolBarAreasSuperConst (..),
ListenerToolButtonStyleValue (..),
ListenerToolButtonStyleConstPtr (..),
ListenerToolButtonStylePtr (..),
listenerToolButtonStyle_connectListener,
ListenerToolButtonStyleConst (..),
castListenerToolButtonStyleToConst,
ListenerToolButtonStyle (..),
castListenerToolButtonStyleToNonconst,
listenerToolButtonStyle_new,
listenerToolButtonStyle_newWithParent,
ListenerToolButtonStyleSuper (..),
ListenerToolButtonStyleSuperConst (..),
ListenerWindowModalityValue (..),
ListenerWindowModalityConstPtr (..),
ListenerWindowModalityPtr (..),
listenerWindowModality_connectListener,
ListenerWindowModalityConst (..),
castListenerWindowModalityToConst,
ListenerWindowModality (..),
castListenerWindowModalityToNonconst,
listenerWindowModality_new,
listenerWindowModality_newWithParent,
ListenerWindowModalitySuper (..),
ListenerWindowModalitySuperConst (..),
ListenerWindowStateValue (..),
ListenerWindowStateConstPtr (..),
ListenerWindowStatePtr (..),
listenerWindowState_connectListener,
ListenerWindowStateConst (..),
castListenerWindowStateToConst,
ListenerWindowState (..),
castListenerWindowStateToNonconst,
listenerWindowState_new,
listenerWindowState_newWithParent,
ListenerWindowStateSuper (..),
ListenerWindowStateSuperConst (..),
) where
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.Generated.Core.QAbstractItemModel as M2
import qualified Graphics.UI.Qtah.Generated.Core.QDate as M16
import qualified Graphics.UI.Qtah.Generated.Core.QItemSelection as M22
import qualified Graphics.UI.Qtah.Generated.Core.QModelIndex as M32
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M34
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M40
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M50
import qualified Graphics.UI.Qtah.Generated.Core.QString as M54
import qualified Graphics.UI.Qtah.Generated.Core.QVector.Int as M90
import qualified Graphics.UI.Qtah.Generated.Core.Types as M68
import qualified Graphics.UI.Qtah.Generated.Gui.QClipboard as M102
import qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M124
import qualified Graphics.UI.Qtah.Generated.Gui.QWindow as M176
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractButton as M188
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractSlider as M198
import qualified Graphics.UI.Qtah.Generated.Widgets.QAction as M202
import qualified Graphics.UI.Qtah.Generated.Widgets.QDockWidget as M224
import qualified Graphics.UI.Qtah.Generated.Widgets.QSystemTrayIcon as M310
import qualified Graphics.UI.Qtah.Generated.Widgets.QTreeWidgetItem as M326
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M330
import qualified Graphics.UI.Qtah.Internal.Callback as M182
import qualified Graphics.UI.Qtah.Std as M1
import Prelude (($), (.), (/=), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP
foreign import ccall "genpop__Listener_new" listener_new' :: HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr Listener)
foreign import ccall "genpop__Listener_newWithParent" listener_newWithParent' :: HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr Listener)
foreign import ccall "genpop__Listener_connectListener" listener_connectListener' :: HoppyF.Ptr Listener -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__Listener__QObject" castListenerToQObject :: HoppyF.Ptr ListenerConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__Listener" castQObjectToListener :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerConst
foreign import ccall "gendel__Listener" delete'Listener :: HoppyF.Ptr ListenerConst -> HoppyP.IO ()
foreign import ccall "&gendel__Listener" deletePtr'Listener :: HoppyF.FunPtr (HoppyF.Ptr ListenerConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerBool_new" listenerBool_new' :: HoppyFHR.CCallback (HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerBool)
foreign import ccall "genpop__ListenerBool_newWithParent" listenerBool_newWithParent' :: HoppyFHR.CCallback (HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerBool)
foreign import ccall "genpop__ListenerBool_connectListener" listenerBool_connectListener' :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerBool__QObject" castListenerBoolToQObject :: HoppyF.Ptr ListenerBoolConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerBool" castQObjectToListenerBool :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerBoolConst
foreign import ccall "gendel__ListenerBool" delete'ListenerBool :: HoppyF.Ptr ListenerBoolConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerBool" deletePtr'ListenerBool :: HoppyF.FunPtr (HoppyF.Ptr ListenerBoolConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerDockWidgetArea_new" listenerDockWidgetArea_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerDockWidgetArea)
foreign import ccall "genpop__ListenerDockWidgetArea_newWithParent" listenerDockWidgetArea_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerDockWidgetArea)
foreign import ccall "genpop__ListenerDockWidgetArea_connectListener" listenerDockWidgetArea_connectListener' :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerDockWidgetArea__QObject" castListenerDockWidgetAreaToQObject :: HoppyF.Ptr ListenerDockWidgetAreaConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerDockWidgetArea" castQObjectToListenerDockWidgetArea :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerDockWidgetAreaConst
foreign import ccall "gendel__ListenerDockWidgetArea" delete'ListenerDockWidgetArea :: HoppyF.Ptr ListenerDockWidgetAreaConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerDockWidgetArea" deletePtr'ListenerDockWidgetArea :: HoppyF.FunPtr (HoppyF.Ptr ListenerDockWidgetAreaConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerDockWidgetAreas_new" listenerDockWidgetAreas_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerDockWidgetAreas)
foreign import ccall "genpop__ListenerDockWidgetAreas_newWithParent" listenerDockWidgetAreas_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerDockWidgetAreas)
foreign import ccall "genpop__ListenerDockWidgetAreas_connectListener" listenerDockWidgetAreas_connectListener' :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerDockWidgetAreas__QObject" castListenerDockWidgetAreasToQObject :: HoppyF.Ptr ListenerDockWidgetAreasConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerDockWidgetAreas" castQObjectToListenerDockWidgetAreas :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerDockWidgetAreasConst
foreign import ccall "gendel__ListenerDockWidgetAreas" delete'ListenerDockWidgetAreas :: HoppyF.Ptr ListenerDockWidgetAreasConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerDockWidgetAreas" deletePtr'ListenerDockWidgetAreas :: HoppyF.FunPtr (HoppyF.Ptr ListenerDockWidgetAreasConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerDouble_new" listenerDouble_new' :: HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerDouble)
foreign import ccall "genpop__ListenerDouble_newWithParent" listenerDouble_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerDouble)
foreign import ccall "genpop__ListenerDouble_connectListener" listenerDouble_connectListener' :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerDouble__QObject" castListenerDoubleToQObject :: HoppyF.Ptr ListenerDoubleConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerDouble" castQObjectToListenerDouble :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerDoubleConst
foreign import ccall "gendel__ListenerDouble" delete'ListenerDouble :: HoppyF.Ptr ListenerDoubleConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerDouble" deletePtr'ListenerDouble :: HoppyF.FunPtr (HoppyF.Ptr ListenerDoubleConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerInt_new" listenerInt_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerInt)
foreign import ccall "genpop__ListenerInt_newWithParent" listenerInt_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerInt)
foreign import ccall "genpop__ListenerInt_connectListener" listenerInt_connectListener' :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerInt__QObject" castListenerIntToQObject :: HoppyF.Ptr ListenerIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerInt" castQObjectToListenerInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerIntConst
foreign import ccall "gendel__ListenerInt" delete'ListenerInt :: HoppyF.Ptr ListenerIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerInt" deletePtr'ListenerInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerIntBool_new" listenerIntBool_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerIntBool)
foreign import ccall "genpop__ListenerIntBool_newWithParent" listenerIntBool_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerIntBool)
foreign import ccall "genpop__ListenerIntBool_connectListener" listenerIntBool_connectListener' :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerIntBool__QObject" castListenerIntBoolToQObject :: HoppyF.Ptr ListenerIntBoolConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerIntBool" castQObjectToListenerIntBool :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerIntBoolConst
foreign import ccall "gendel__ListenerIntBool" delete'ListenerIntBool :: HoppyF.Ptr ListenerIntBoolConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerIntBool" deletePtr'ListenerIntBool :: HoppyF.FunPtr (HoppyF.Ptr ListenerIntBoolConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerIntInt_new" listenerIntInt_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerIntInt)
foreign import ccall "genpop__ListenerIntInt_newWithParent" listenerIntInt_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerIntInt)
foreign import ccall "genpop__ListenerIntInt_connectListener" listenerIntInt_connectListener' :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerIntInt__QObject" castListenerIntIntToQObject :: HoppyF.Ptr ListenerIntIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerIntInt" castQObjectToListenerIntInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerIntIntConst
foreign import ccall "gendel__ListenerIntInt" delete'ListenerIntInt :: HoppyF.Ptr ListenerIntIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerIntInt" deletePtr'ListenerIntInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerIntIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerOrientation_new" listenerOrientation_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerOrientation)
foreign import ccall "genpop__ListenerOrientation_newWithParent" listenerOrientation_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerOrientation)
foreign import ccall "genpop__ListenerOrientation_connectListener" listenerOrientation_connectListener' :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerOrientation__QObject" castListenerOrientationToQObject :: HoppyF.Ptr ListenerOrientationConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerOrientation" castQObjectToListenerOrientation :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerOrientationConst
foreign import ccall "gendel__ListenerOrientation" delete'ListenerOrientation :: HoppyF.Ptr ListenerOrientationConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerOrientation" deletePtr'ListenerOrientation :: HoppyF.FunPtr (HoppyF.Ptr ListenerOrientationConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQAbstractButton_new" listenerPtrQAbstractButton_new' :: HoppyFHR.CCallback (HoppyF.Ptr M188.QAbstractButton -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractButton)
foreign import ccall "genpop__ListenerPtrQAbstractButton_newWithParent" listenerPtrQAbstractButton_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M188.QAbstractButton -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractButton)
foreign import ccall "genpop__ListenerPtrQAbstractButton_connectListener" listenerPtrQAbstractButton_connectListener' :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQAbstractButton__QObject" castListenerPtrQAbstractButtonToQObject :: HoppyF.Ptr ListenerPtrQAbstractButtonConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQAbstractButton" castQObjectToListenerPtrQAbstractButton :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQAbstractButtonConst
foreign import ccall "gendel__ListenerPtrQAbstractButton" delete'ListenerPtrQAbstractButton :: HoppyF.Ptr ListenerPtrQAbstractButtonConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQAbstractButton" deletePtr'ListenerPtrQAbstractButton :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQAbstractButtonConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQAbstractButtonBool_new" listenerPtrQAbstractButtonBool_new' :: HoppyFHR.CCallback (HoppyF.Ptr M188.QAbstractButton -> HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractButtonBool)
foreign import ccall "genpop__ListenerPtrQAbstractButtonBool_newWithParent" listenerPtrQAbstractButtonBool_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M188.QAbstractButton -> HoppyFHR.CBool -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractButtonBool)
foreign import ccall "genpop__ListenerPtrQAbstractButtonBool_connectListener" listenerPtrQAbstractButtonBool_connectListener' :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQAbstractButtonBool__QObject" castListenerPtrQAbstractButtonBoolToQObject :: HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQAbstractButtonBool" castQObjectToListenerPtrQAbstractButtonBool :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst
foreign import ccall "gendel__ListenerPtrQAbstractButtonBool" delete'ListenerPtrQAbstractButtonBool :: HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQAbstractButtonBool" deletePtr'ListenerPtrQAbstractButtonBool :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQAbstractItemModel_new" listenerPtrQAbstractItemModel_new' :: HoppyFHR.CCallback (HoppyF.Ptr M2.QAbstractItemModel -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractItemModel)
foreign import ccall "genpop__ListenerPtrQAbstractItemModel_newWithParent" listenerPtrQAbstractItemModel_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M2.QAbstractItemModel -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAbstractItemModel)
foreign import ccall "genpop__ListenerPtrQAbstractItemModel_connectListener" listenerPtrQAbstractItemModel_connectListener' :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQAbstractItemModel__QObject" castListenerPtrQAbstractItemModelToQObject :: HoppyF.Ptr ListenerPtrQAbstractItemModelConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQAbstractItemModel" castQObjectToListenerPtrQAbstractItemModel :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst
foreign import ccall "gendel__ListenerPtrQAbstractItemModel" delete'ListenerPtrQAbstractItemModel :: HoppyF.Ptr ListenerPtrQAbstractItemModelConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQAbstractItemModel" deletePtr'ListenerPtrQAbstractItemModel :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQAbstractItemModelConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQAction_new" listenerPtrQAction_new' :: HoppyFHR.CCallback (HoppyF.Ptr M202.QAction -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAction)
foreign import ccall "genpop__ListenerPtrQAction_newWithParent" listenerPtrQAction_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M202.QAction -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQAction)
foreign import ccall "genpop__ListenerPtrQAction_connectListener" listenerPtrQAction_connectListener' :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQAction__QObject" castListenerPtrQActionToQObject :: HoppyF.Ptr ListenerPtrQActionConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQAction" castQObjectToListenerPtrQAction :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQActionConst
foreign import ccall "gendel__ListenerPtrQAction" delete'ListenerPtrQAction :: HoppyF.Ptr ListenerPtrQActionConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQAction" deletePtr'ListenerPtrQAction :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQActionConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQObject_new" listenerPtrQObject_new' :: HoppyFHR.CCallback (HoppyF.Ptr M34.QObject -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQObject)
foreign import ccall "genpop__ListenerPtrQObject_newWithParent" listenerPtrQObject_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M34.QObject -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQObject)
foreign import ccall "genpop__ListenerPtrQObject_connectListener" listenerPtrQObject_connectListener' :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQObject__QObject" castListenerPtrQObjectToQObject :: HoppyF.Ptr ListenerPtrQObjectConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQObject" castQObjectToListenerPtrQObject :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQObjectConst
foreign import ccall "gendel__ListenerPtrQObject" delete'ListenerPtrQObject :: HoppyF.Ptr ListenerPtrQObjectConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQObject" deletePtr'ListenerPtrQObject :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQObjectConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQTreeWidgetItem_new" listenerPtrQTreeWidgetItem_new' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItem)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItem_newWithParent" listenerPtrQTreeWidgetItem_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItem)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItem_connectListener" listenerPtrQTreeWidgetItem_connectListener' :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQTreeWidgetItem__QObject" castListenerPtrQTreeWidgetItemToQObject :: HoppyF.Ptr ListenerPtrQTreeWidgetItemConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQTreeWidgetItem" castQObjectToListenerPtrQTreeWidgetItem :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst
foreign import ccall "gendel__ListenerPtrQTreeWidgetItem" delete'ListenerPtrQTreeWidgetItem :: HoppyF.Ptr ListenerPtrQTreeWidgetItemConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQTreeWidgetItem" deletePtr'ListenerPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQTreeWidgetItemConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemInt_new" listenerPtrQTreeWidgetItemInt_new' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemInt_newWithParent" listenerPtrQTreeWidgetItemInt_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemInt_connectListener" listenerPtrQTreeWidgetItemInt_connectListener' :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQTreeWidgetItemInt__QObject" castListenerPtrQTreeWidgetItemIntToQObject :: HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQTreeWidgetItemInt" castQObjectToListenerPtrQTreeWidgetItemInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst
foreign import ccall "gendel__ListenerPtrQTreeWidgetItemInt" delete'ListenerPtrQTreeWidgetItemInt :: HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQTreeWidgetItemInt" deletePtr'ListenerPtrQTreeWidgetItemInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new" listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyF.Ptr M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent" listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M326.QTreeWidgetItem -> HoppyF.Ptr M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)
foreign import ccall "genpop__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener" listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener' :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem__QObject" castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem" castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst
foreign import ccall "gendel__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem" delete'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem" deletePtr'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerPtrQWidgetPtrQWidget_new" listenerPtrQWidgetPtrQWidget_new' :: HoppyFHR.CCallback (HoppyF.Ptr M330.QWidget -> HoppyF.Ptr M330.QWidget -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)
foreign import ccall "genpop__ListenerPtrQWidgetPtrQWidget_newWithParent" listenerPtrQWidgetPtrQWidget_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M330.QWidget -> HoppyF.Ptr M330.QWidget -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)
foreign import ccall "genpop__ListenerPtrQWidgetPtrQWidget_connectListener" listenerPtrQWidgetPtrQWidget_connectListener' :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerPtrQWidgetPtrQWidget__QObject" castListenerPtrQWidgetPtrQWidgetToQObject :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerPtrQWidgetPtrQWidget" castQObjectToListenerPtrQWidgetPtrQWidget :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst
foreign import ccall "gendel__ListenerPtrQWidgetPtrQWidget" delete'ListenerPtrQWidgetPtrQWidget :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerPtrQWidgetPtrQWidget" deletePtr'ListenerPtrQWidgetPtrQWidget :: HoppyF.FunPtr (HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQAbstractSliderAction_new" listenerQAbstractSliderAction_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQAbstractSliderAction)
foreign import ccall "genpop__ListenerQAbstractSliderAction_newWithParent" listenerQAbstractSliderAction_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQAbstractSliderAction)
foreign import ccall "genpop__ListenerQAbstractSliderAction_connectListener" listenerQAbstractSliderAction_connectListener' :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQAbstractSliderAction__QObject" castListenerQAbstractSliderActionToQObject :: HoppyF.Ptr ListenerQAbstractSliderActionConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQAbstractSliderAction" castQObjectToListenerQAbstractSliderAction :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQAbstractSliderActionConst
foreign import ccall "gendel__ListenerQAbstractSliderAction" delete'ListenerQAbstractSliderAction :: HoppyF.Ptr ListenerQAbstractSliderActionConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQAbstractSliderAction" deletePtr'ListenerQAbstractSliderAction :: HoppyF.FunPtr (HoppyF.Ptr ListenerQAbstractSliderActionConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQClipboardMode_new" listenerQClipboardMode_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQClipboardMode)
foreign import ccall "genpop__ListenerQClipboardMode_newWithParent" listenerQClipboardMode_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQClipboardMode)
foreign import ccall "genpop__ListenerQClipboardMode_connectListener" listenerQClipboardMode_connectListener' :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQClipboardMode__QObject" castListenerQClipboardModeToQObject :: HoppyF.Ptr ListenerQClipboardModeConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQClipboardMode" castQObjectToListenerQClipboardMode :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQClipboardModeConst
foreign import ccall "gendel__ListenerQClipboardMode" delete'ListenerQClipboardMode :: HoppyF.Ptr ListenerQClipboardModeConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQClipboardMode" deletePtr'ListenerQClipboardMode :: HoppyF.FunPtr (HoppyF.Ptr ListenerQClipboardModeConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQDate_new" listenerQDate_new' :: HoppyFHR.CCallback (HoppyF.Ptr M16.QDateConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQDate)
foreign import ccall "genpop__ListenerQDate_newWithParent" listenerQDate_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M16.QDateConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQDate)
foreign import ccall "genpop__ListenerQDate_connectListener" listenerQDate_connectListener' :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQDate__QObject" castListenerQDateToQObject :: HoppyF.Ptr ListenerQDateConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQDate" castQObjectToListenerQDate :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQDateConst
foreign import ccall "gendel__ListenerQDate" delete'ListenerQDate :: HoppyF.Ptr ListenerQDateConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQDate" deletePtr'ListenerQDate :: HoppyF.FunPtr (HoppyF.Ptr ListenerQDateConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQDockWidgetFeatures_new" listenerQDockWidgetFeatures_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQDockWidgetFeatures)
foreign import ccall "genpop__ListenerQDockWidgetFeatures_newWithParent" listenerQDockWidgetFeatures_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQDockWidgetFeatures)
foreign import ccall "genpop__ListenerQDockWidgetFeatures_connectListener" listenerQDockWidgetFeatures_connectListener' :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQDockWidgetFeatures__QObject" castListenerQDockWidgetFeaturesToQObject :: HoppyF.Ptr ListenerQDockWidgetFeaturesConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQDockWidgetFeatures" castQObjectToListenerQDockWidgetFeatures :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst
foreign import ccall "gendel__ListenerQDockWidgetFeatures" delete'ListenerQDockWidgetFeatures :: HoppyF.Ptr ListenerQDockWidgetFeaturesConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQDockWidgetFeatures" deletePtr'ListenerQDockWidgetFeatures :: HoppyF.FunPtr (HoppyF.Ptr ListenerQDockWidgetFeaturesConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQModelIndex_new" listenerQModelIndex_new' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndex)
foreign import ccall "genpop__ListenerQModelIndex_newWithParent" listenerQModelIndex_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndex)
foreign import ccall "genpop__ListenerQModelIndex_connectListener" listenerQModelIndex_connectListener' :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQModelIndex__QObject" castListenerQModelIndexToQObject :: HoppyF.Ptr ListenerQModelIndexConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQModelIndex" castQObjectToListenerQModelIndex :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQModelIndexConst
foreign import ccall "gendel__ListenerQModelIndex" delete'ListenerQModelIndex :: HoppyF.Ptr ListenerQModelIndexConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQModelIndex" deletePtr'ListenerQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr ListenerQModelIndexConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQModelIndexIntInt_new" listenerQModelIndexIntInt_new' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexIntInt)
foreign import ccall "genpop__ListenerQModelIndexIntInt_newWithParent" listenerQModelIndexIntInt_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexIntInt)
foreign import ccall "genpop__ListenerQModelIndexIntInt_connectListener" listenerQModelIndexIntInt_connectListener' :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQModelIndexIntInt__QObject" castListenerQModelIndexIntIntToQObject :: HoppyF.Ptr ListenerQModelIndexIntIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQModelIndexIntInt" castQObjectToListenerQModelIndexIntInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQModelIndexIntIntConst
foreign import ccall "gendel__ListenerQModelIndexIntInt" delete'ListenerQModelIndexIntInt :: HoppyF.Ptr ListenerQModelIndexIntIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQModelIndexIntInt" deletePtr'ListenerQModelIndexIntInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerQModelIndexIntIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQModelIndexIntIntQModelIndexInt_new" listenerQModelIndexIntIntQModelIndexInt_new' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)
foreign import ccall "genpop__ListenerQModelIndexIntIntQModelIndexInt_newWithParent" listenerQModelIndexIntIntQModelIndexInt_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M32.QModelIndexConst -> HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)
foreign import ccall "genpop__ListenerQModelIndexIntIntQModelIndexInt_connectListener" listenerQModelIndexIntIntQModelIndexInt_connectListener' :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQModelIndexIntIntQModelIndexInt__QObject" castListenerQModelIndexIntIntQModelIndexIntToQObject :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQModelIndexIntIntQModelIndexInt" castQObjectToListenerQModelIndexIntIntQModelIndexInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst
foreign import ccall "gendel__ListenerQModelIndexIntIntQModelIndexInt" delete'ListenerQModelIndexIntIntQModelIndexInt :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQModelIndexIntIntQModelIndexInt" deletePtr'ListenerQModelIndexIntIntQModelIndexInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQModelIndexQModelIndex_new" listenerQModelIndexQModelIndex_new' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M32.QModelIndexConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexQModelIndex)
foreign import ccall "genpop__ListenerQModelIndexQModelIndex_newWithParent" listenerQModelIndexQModelIndex_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M32.QModelIndexConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexQModelIndex)
foreign import ccall "genpop__ListenerQModelIndexQModelIndex_connectListener" listenerQModelIndexQModelIndex_connectListener' :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQModelIndexQModelIndex__QObject" castListenerQModelIndexQModelIndexToQObject :: HoppyF.Ptr ListenerQModelIndexQModelIndexConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQModelIndexQModelIndex" castQObjectToListenerQModelIndexQModelIndex :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst
foreign import ccall "gendel__ListenerQModelIndexQModelIndex" delete'ListenerQModelIndexQModelIndex :: HoppyF.Ptr ListenerQModelIndexQModelIndexConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQModelIndexQModelIndex" deletePtr'ListenerQModelIndexQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr ListenerQModelIndexQModelIndexConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQModelIndexQModelIndexQVectorInt_new" listenerQModelIndexQModelIndexQVectorInt_new' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M90.QVectorInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)
foreign import ccall "genpop__ListenerQModelIndexQModelIndexQVectorInt_newWithParent" listenerQModelIndexQModelIndexQVectorInt_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M32.QModelIndexConst -> HoppyF.Ptr M90.QVectorInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)
foreign import ccall "genpop__ListenerQModelIndexQModelIndexQVectorInt_connectListener" listenerQModelIndexQModelIndexQVectorInt_connectListener' :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQModelIndexQModelIndexQVectorInt__QObject" castListenerQModelIndexQModelIndexQVectorIntToQObject :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQModelIndexQModelIndexQVectorInt" castQObjectToListenerQModelIndexQModelIndexQVectorInt :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst
foreign import ccall "gendel__ListenerQModelIndexQModelIndexQVectorInt" delete'ListenerQModelIndexQModelIndexQVectorInt :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQModelIndexQModelIndexQVectorInt" deletePtr'ListenerQModelIndexQModelIndexQVectorInt :: HoppyF.FunPtr (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQPoint_new" listenerQPoint_new' :: HoppyFHR.CCallback (HoppyF.Ptr M40.QPointConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQPoint)
foreign import ccall "genpop__ListenerQPoint_newWithParent" listenerQPoint_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M40.QPointConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQPoint)
foreign import ccall "genpop__ListenerQPoint_connectListener" listenerQPoint_connectListener' :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQPoint__QObject" castListenerQPointToQObject :: HoppyF.Ptr ListenerQPointConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQPoint" castQObjectToListenerQPoint :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQPointConst
foreign import ccall "gendel__ListenerQPoint" delete'ListenerQPoint :: HoppyF.Ptr ListenerQPointConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQPoint" deletePtr'ListenerQPoint :: HoppyF.FunPtr (HoppyF.Ptr ListenerQPointConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQSize_new" listenerQSize_new' :: HoppyFHR.CCallback (HoppyF.Ptr M50.QSizeConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQSize)
foreign import ccall "genpop__ListenerQSize_newWithParent" listenerQSize_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M50.QSizeConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQSize)
foreign import ccall "genpop__ListenerQSize_connectListener" listenerQSize_connectListener' :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQSize__QObject" castListenerQSizeToQObject :: HoppyF.Ptr ListenerQSizeConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQSize" castQObjectToListenerQSize :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQSizeConst
foreign import ccall "gendel__ListenerQSize" delete'ListenerQSize :: HoppyF.Ptr ListenerQSizeConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQSize" deletePtr'ListenerQSize :: HoppyF.FunPtr (HoppyF.Ptr ListenerQSizeConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQString_new" listenerQString_new' :: HoppyFHR.CCallback (HoppyF.Ptr M54.QStringConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQString)
foreign import ccall "genpop__ListenerQString_newWithParent" listenerQString_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M54.QStringConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQString)
foreign import ccall "genpop__ListenerQString_connectListener" listenerQString_connectListener' :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQString__QObject" castListenerQStringToQObject :: HoppyF.Ptr ListenerQStringConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQString" castQObjectToListenerQString :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQStringConst
foreign import ccall "gendel__ListenerQString" delete'ListenerQString :: HoppyF.Ptr ListenerQStringConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQString" deletePtr'ListenerQString :: HoppyF.FunPtr (HoppyF.Ptr ListenerQStringConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQSystemTrayIconActivationReason_new" listenerQSystemTrayIconActivationReason_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)
foreign import ccall "genpop__ListenerQSystemTrayIconActivationReason_newWithParent" listenerQSystemTrayIconActivationReason_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)
foreign import ccall "genpop__ListenerQSystemTrayIconActivationReason_connectListener" listenerQSystemTrayIconActivationReason_connectListener' :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQSystemTrayIconActivationReason__QObject" castListenerQSystemTrayIconActivationReasonToQObject :: HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQSystemTrayIconActivationReason" castQObjectToListenerQSystemTrayIconActivationReason :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst
foreign import ccall "gendel__ListenerQSystemTrayIconActivationReason" delete'ListenerQSystemTrayIconActivationReason :: HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQSystemTrayIconActivationReason" deletePtr'ListenerQSystemTrayIconActivationReason :: HoppyF.FunPtr (HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQWindowVisibility_new" listenerQWindowVisibility_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQWindowVisibility)
foreign import ccall "genpop__ListenerQWindowVisibility_newWithParent" listenerQWindowVisibility_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQWindowVisibility)
foreign import ccall "genpop__ListenerQWindowVisibility_connectListener" listenerQWindowVisibility_connectListener' :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQWindowVisibility__QObject" castListenerQWindowVisibilityToQObject :: HoppyF.Ptr ListenerQWindowVisibilityConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQWindowVisibility" castQObjectToListenerQWindowVisibility :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQWindowVisibilityConst
foreign import ccall "gendel__ListenerQWindowVisibility" delete'ListenerQWindowVisibility :: HoppyF.Ptr ListenerQWindowVisibilityConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQWindowVisibility" deletePtr'ListenerQWindowVisibility :: HoppyF.FunPtr (HoppyF.Ptr ListenerQWindowVisibilityConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerQreal_new" listenerQreal_new' :: HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerQreal)
foreign import ccall "genpop__ListenerQreal_newWithParent" listenerQreal_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CDouble -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerQreal)
foreign import ccall "genpop__ListenerQreal_connectListener" listenerQreal_connectListener' :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerQreal__QObject" castListenerQrealToQObject :: HoppyF.Ptr ListenerQrealConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerQreal" castQObjectToListenerQreal :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerQrealConst
foreign import ccall "gendel__ListenerQreal" delete'ListenerQreal :: HoppyF.Ptr ListenerQrealConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerQreal" deletePtr'ListenerQreal :: HoppyF.FunPtr (HoppyF.Ptr ListenerQrealConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerRefConstQIcon_new" listenerRefConstQIcon_new' :: HoppyFHR.CCallback (HoppyF.Ptr M124.QIconConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerRefConstQIcon)
foreign import ccall "genpop__ListenerRefConstQIcon_newWithParent" listenerRefConstQIcon_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M124.QIconConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerRefConstQIcon)
foreign import ccall "genpop__ListenerRefConstQIcon_connectListener" listenerRefConstQIcon_connectListener' :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerRefConstQIcon__QObject" castListenerRefConstQIconToQObject :: HoppyF.Ptr ListenerRefConstQIconConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerRefConstQIcon" castQObjectToListenerRefConstQIcon :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerRefConstQIconConst
foreign import ccall "gendel__ListenerRefConstQIcon" delete'ListenerRefConstQIcon :: HoppyF.Ptr ListenerRefConstQIconConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerRefConstQIcon" deletePtr'ListenerRefConstQIcon :: HoppyF.FunPtr (HoppyF.Ptr ListenerRefConstQIconConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerRefConstQItemSelectionRefConstQItemSelection_new" listenerRefConstQItemSelectionRefConstQItemSelection_new' :: HoppyFHR.CCallback (HoppyF.Ptr M22.QItemSelectionConst -> HoppyF.Ptr M22.QItemSelectionConst -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)
foreign import ccall "genpop__ListenerRefConstQItemSelectionRefConstQItemSelection_newWithParent" listenerRefConstQItemSelectionRefConstQItemSelection_newWithParent' :: HoppyFHR.CCallback (HoppyF.Ptr M22.QItemSelectionConst -> HoppyF.Ptr M22.QItemSelectionConst -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)
foreign import ccall "genpop__ListenerRefConstQItemSelectionRefConstQItemSelection_connectListener" listenerRefConstQItemSelectionRefConstQItemSelection_connectListener' :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerRefConstQItemSelectionRefConstQItemSelection__QObject" castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerRefConstQItemSelectionRefConstQItemSelection" castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst
foreign import ccall "gendel__ListenerRefConstQItemSelectionRefConstQItemSelection" delete'ListenerRefConstQItemSelectionRefConstQItemSelection :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerRefConstQItemSelectionRefConstQItemSelection" deletePtr'ListenerRefConstQItemSelectionRefConstQItemSelection :: HoppyF.FunPtr (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerScreenOrientation_new" listenerScreenOrientation_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerScreenOrientation)
foreign import ccall "genpop__ListenerScreenOrientation_newWithParent" listenerScreenOrientation_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerScreenOrientation)
foreign import ccall "genpop__ListenerScreenOrientation_connectListener" listenerScreenOrientation_connectListener' :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerScreenOrientation__QObject" castListenerScreenOrientationToQObject :: HoppyF.Ptr ListenerScreenOrientationConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerScreenOrientation" castQObjectToListenerScreenOrientation :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerScreenOrientationConst
foreign import ccall "gendel__ListenerScreenOrientation" delete'ListenerScreenOrientation :: HoppyF.Ptr ListenerScreenOrientationConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerScreenOrientation" deletePtr'ListenerScreenOrientation :: HoppyF.FunPtr (HoppyF.Ptr ListenerScreenOrientationConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerToolBarAreas_new" listenerToolBarAreas_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerToolBarAreas)
foreign import ccall "genpop__ListenerToolBarAreas_newWithParent" listenerToolBarAreas_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerToolBarAreas)
foreign import ccall "genpop__ListenerToolBarAreas_connectListener" listenerToolBarAreas_connectListener' :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerToolBarAreas__QObject" castListenerToolBarAreasToQObject :: HoppyF.Ptr ListenerToolBarAreasConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerToolBarAreas" castQObjectToListenerToolBarAreas :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerToolBarAreasConst
foreign import ccall "gendel__ListenerToolBarAreas" delete'ListenerToolBarAreas :: HoppyF.Ptr ListenerToolBarAreasConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerToolBarAreas" deletePtr'ListenerToolBarAreas :: HoppyF.FunPtr (HoppyF.Ptr ListenerToolBarAreasConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerToolButtonStyle_new" listenerToolButtonStyle_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerToolButtonStyle)
foreign import ccall "genpop__ListenerToolButtonStyle_newWithParent" listenerToolButtonStyle_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerToolButtonStyle)
foreign import ccall "genpop__ListenerToolButtonStyle_connectListener" listenerToolButtonStyle_connectListener' :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerToolButtonStyle__QObject" castListenerToolButtonStyleToQObject :: HoppyF.Ptr ListenerToolButtonStyleConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerToolButtonStyle" castQObjectToListenerToolButtonStyle :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerToolButtonStyleConst
foreign import ccall "gendel__ListenerToolButtonStyle" delete'ListenerToolButtonStyle :: HoppyF.Ptr ListenerToolButtonStyleConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerToolButtonStyle" deletePtr'ListenerToolButtonStyle :: HoppyF.FunPtr (HoppyF.Ptr ListenerToolButtonStyleConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerWindowModality_new" listenerWindowModality_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerWindowModality)
foreign import ccall "genpop__ListenerWindowModality_newWithParent" listenerWindowModality_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerWindowModality)
foreign import ccall "genpop__ListenerWindowModality_connectListener" listenerWindowModality_connectListener' :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerWindowModality__QObject" castListenerWindowModalityToQObject :: HoppyF.Ptr ListenerWindowModalityConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerWindowModality" castQObjectToListenerWindowModality :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerWindowModalityConst
foreign import ccall "gendel__ListenerWindowModality" delete'ListenerWindowModality :: HoppyF.Ptr ListenerWindowModalityConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerWindowModality" deletePtr'ListenerWindowModality :: HoppyF.FunPtr (HoppyF.Ptr ListenerWindowModalityConst -> HoppyP.IO ())
foreign import ccall "genpop__ListenerWindowState_new" listenerWindowState_new' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr ListenerWindowState)
foreign import ccall "genpop__ListenerWindowState_newWithParent" listenerWindowState_newWithParent' :: HoppyFHR.CCallback (HoppyFC.CInt -> HoppyP.IO ()) -> HoppyF.Ptr M34.QObject -> HoppyP.IO (HoppyF.Ptr ListenerWindowState)
foreign import ccall "genpop__ListenerWindowState_connectListener" listenerWindowState_connectListener' :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr M34.QObject -> HoppyF.Ptr M1.StdStringConst -> HoppyP.IO HoppyFHR.CBool
foreign import ccall "gencast__ListenerWindowState__QObject" castListenerWindowStateToQObject :: HoppyF.Ptr ListenerWindowStateConst -> HoppyF.Ptr M34.QObjectConst
foreign import ccall "gencast__QObject__ListenerWindowState" castQObjectToListenerWindowState :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr ListenerWindowStateConst
foreign import ccall "gendel__ListenerWindowState" delete'ListenerWindowState :: HoppyF.Ptr ListenerWindowStateConst -> HoppyP.IO ()
foreign import ccall "&gendel__ListenerWindowState" deletePtr'ListenerWindowState :: HoppyF.FunPtr (HoppyF.Ptr ListenerWindowStateConst -> HoppyP.IO ())
class ListenerValue a where
withListenerPtr :: a -> (ListenerConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerConstPtr a => ListenerValue a where
withListenerPtr = HoppyP.flip ($) . toListenerConst
class (M34.QObjectConstPtr this) => ListenerConstPtr this where
toListenerConst :: this -> ListenerConst
class (ListenerConstPtr this, M34.QObjectPtr this) => ListenerPtr this where
toListener :: this -> Listener
listener_connectListener :: (ListenerPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listener_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListener arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listener_connectListener' arg'1' arg'2' arg'3')
data ListenerConst =
ListenerConst (HoppyF.Ptr ListenerConst)
| ListenerConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToConst :: Listener -> ListenerConst
castListenerToConst (Listener ptr') = ListenerConst $ HoppyF.castPtr ptr'
castListenerToConst (ListenerGc fptr' ptr') = ListenerConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerConst where
nullptr = ListenerConst HoppyF.nullPtr
withCppPtr (ListenerConst ptr') f' = f' ptr'
withCppPtr (ListenerConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerConst ptr') = ptr'
toPtr (ListenerConstGc _ ptr') = ptr'
touchCppPtr (ListenerConst _) = HoppyP.return ()
touchCppPtr (ListenerConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerConst where
delete (ListenerConst ptr') = delete'Listener ptr'
delete (ListenerConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerConst", " object."]
toGc this'@(ListenerConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'Listener :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerConstGc {}) = HoppyP.return this'
instance ListenerConstPtr ListenerConst where
toListenerConst = HoppyP.id
instance M34.QObjectConstPtr ListenerConst where
toQObjectConst (ListenerConst ptr') = M34.QObjectConst $ castListenerToQObject ptr'
toQObjectConst (ListenerConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToQObject ptr'
data Listener =
Listener (HoppyF.Ptr Listener)
| ListenerGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr Listener)
deriving (HoppyP.Show)
instance HoppyP.Eq Listener where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord Listener where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToNonconst :: ListenerConst -> Listener
castListenerToNonconst (ListenerConst ptr') = Listener $ HoppyF.castPtr ptr'
castListenerToNonconst (ListenerConstGc fptr' ptr') = ListenerGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr Listener where
nullptr = Listener HoppyF.nullPtr
withCppPtr (Listener ptr') f' = f' ptr'
withCppPtr (ListenerGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (Listener ptr') = ptr'
toPtr (ListenerGc _ ptr') = ptr'
touchCppPtr (Listener _) = HoppyP.return ()
touchCppPtr (ListenerGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable Listener where
delete (Listener ptr') = delete'Listener $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerConst)
delete (ListenerGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "Listener", " object."]
toGc this'@(Listener ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'Listener :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerGc {}) = HoppyP.return this'
instance ListenerConstPtr Listener where
toListenerConst (Listener ptr') = ListenerConst $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
toListenerConst (ListenerGc fptr' ptr') = ListenerConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
instance ListenerPtr Listener where
toListener = HoppyP.id
instance M34.QObjectConstPtr Listener where
toQObjectConst (Listener ptr') = M34.QObjectConst $ castListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
toQObjectConst (ListenerGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
instance M34.QObjectPtr Listener where
toQObject (Listener ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
toQObject (ListenerGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr Listener -> HoppyF.Ptr ListenerConst) ptr'
listener_new :: HoppyP.IO () -> HoppyP.IO Listener
listener_new arg'1 =
M182.callbackVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap Listener
(listener_new' arg'1')
listener_newWithParent :: (M34.QObjectPtr arg'2) => HoppyP.IO () -> arg'2 -> HoppyP.IO Listener
listener_newWithParent arg'1 arg'2 =
M182.callbackVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap Listener
(listener_newWithParent' arg'1' arg'2')
class ListenerSuper a where
downToListener :: a -> Listener
instance ListenerSuper M34.QObject where
downToListener = castListenerToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerConst $ castQObjectToListener ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerConstGc fptr' $ castQObjectToListener ptr'
class ListenerSuperConst a where
downToListenerConst :: a -> ListenerConst
instance ListenerSuperConst M34.QObjectConst where
downToListenerConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerConst $ castQObjectToListener ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerConstGc fptr' $ castQObjectToListener ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr Listener)) Listener where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr Listener)) Listener where
decode = HoppyP.fmap Listener . HoppyF.peek
class ListenerBoolValue a where
withListenerBoolPtr :: a -> (ListenerBoolConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerBoolConstPtr a => ListenerBoolValue a where
withListenerBoolPtr = HoppyP.flip ($) . toListenerBoolConst
class (M34.QObjectConstPtr this) => ListenerBoolConstPtr this where
toListenerBoolConst :: this -> ListenerBoolConst
class (ListenerBoolConstPtr this, M34.QObjectPtr this) => ListenerBoolPtr this where
toListenerBool :: this -> ListenerBool
listenerBool_connectListener :: (ListenerBoolPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerBool_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerBool arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerBool_connectListener' arg'1' arg'2' arg'3')
data ListenerBoolConst =
ListenerBoolConst (HoppyF.Ptr ListenerBoolConst)
| ListenerBoolConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerBoolConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerBoolConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerBoolConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerBoolToConst :: ListenerBool -> ListenerBoolConst
castListenerBoolToConst (ListenerBool ptr') = ListenerBoolConst $ HoppyF.castPtr ptr'
castListenerBoolToConst (ListenerBoolGc fptr' ptr') = ListenerBoolConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerBoolConst where
nullptr = ListenerBoolConst HoppyF.nullPtr
withCppPtr (ListenerBoolConst ptr') f' = f' ptr'
withCppPtr (ListenerBoolConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerBoolConst ptr') = ptr'
toPtr (ListenerBoolConstGc _ ptr') = ptr'
touchCppPtr (ListenerBoolConst _) = HoppyP.return ()
touchCppPtr (ListenerBoolConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerBoolConst where
delete (ListenerBoolConst ptr') = delete'ListenerBool ptr'
delete (ListenerBoolConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerBoolConst", " object."]
toGc this'@(ListenerBoolConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerBoolConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerBoolConstGc {}) = HoppyP.return this'
instance ListenerBoolConstPtr ListenerBoolConst where
toListenerBoolConst = HoppyP.id
instance M34.QObjectConstPtr ListenerBoolConst where
toQObjectConst (ListenerBoolConst ptr') = M34.QObjectConst $ castListenerBoolToQObject ptr'
toQObjectConst (ListenerBoolConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerBoolToQObject ptr'
data ListenerBool =
ListenerBool (HoppyF.Ptr ListenerBool)
| ListenerBoolGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerBool)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerBool where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerBool where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerBoolToNonconst :: ListenerBoolConst -> ListenerBool
castListenerBoolToNonconst (ListenerBoolConst ptr') = ListenerBool $ HoppyF.castPtr ptr'
castListenerBoolToNonconst (ListenerBoolConstGc fptr' ptr') = ListenerBoolGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerBool where
nullptr = ListenerBool HoppyF.nullPtr
withCppPtr (ListenerBool ptr') f' = f' ptr'
withCppPtr (ListenerBoolGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerBool ptr') = ptr'
toPtr (ListenerBoolGc _ ptr') = ptr'
touchCppPtr (ListenerBool _) = HoppyP.return ()
touchCppPtr (ListenerBoolGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerBool where
delete (ListenerBool ptr') = delete'ListenerBool $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerBoolConst)
delete (ListenerBoolGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerBool", " object."]
toGc this'@(ListenerBool ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerBoolGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerBoolGc {}) = HoppyP.return this'
instance ListenerBoolConstPtr ListenerBool where
toListenerBoolConst (ListenerBool ptr') = ListenerBoolConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
toListenerBoolConst (ListenerBoolGc fptr' ptr') = ListenerBoolConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
instance ListenerBoolPtr ListenerBool where
toListenerBool = HoppyP.id
instance M34.QObjectConstPtr ListenerBool where
toQObjectConst (ListenerBool ptr') = M34.QObjectConst $ castListenerBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
toQObjectConst (ListenerBoolGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
instance M34.QObjectPtr ListenerBool where
toQObject (ListenerBool ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
toQObject (ListenerBoolGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerBool -> HoppyF.Ptr ListenerBoolConst) ptr'
listenerBool_new :: (HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO ListenerBool
listenerBool_new arg'1 =
M182.callbackBoolVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerBool
(listenerBool_new' arg'1')
listenerBool_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Bool -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerBool
listenerBool_newWithParent arg'1 arg'2 =
M182.callbackBoolVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerBool
(listenerBool_newWithParent' arg'1' arg'2')
class ListenerBoolSuper a where
downToListenerBool :: a -> ListenerBool
instance ListenerBoolSuper M34.QObject where
downToListenerBool = castListenerBoolToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerBoolConst $ castQObjectToListenerBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerBoolConstGc fptr' $ castQObjectToListenerBool ptr'
class ListenerBoolSuperConst a where
downToListenerBoolConst :: a -> ListenerBoolConst
instance ListenerBoolSuperConst M34.QObjectConst where
downToListenerBoolConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerBoolConst $ castQObjectToListenerBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerBoolConstGc fptr' $ castQObjectToListenerBool ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerBool)) ListenerBool where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerBool)) ListenerBool where
decode = HoppyP.fmap ListenerBool . HoppyF.peek
class ListenerDockWidgetAreaValue a where
withListenerDockWidgetAreaPtr :: a -> (ListenerDockWidgetAreaConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerDockWidgetAreaConstPtr a => ListenerDockWidgetAreaValue a where
withListenerDockWidgetAreaPtr = HoppyP.flip ($) . toListenerDockWidgetAreaConst
class (M34.QObjectConstPtr this) => ListenerDockWidgetAreaConstPtr this where
toListenerDockWidgetAreaConst :: this -> ListenerDockWidgetAreaConst
class (ListenerDockWidgetAreaConstPtr this, M34.QObjectPtr this) => ListenerDockWidgetAreaPtr this where
toListenerDockWidgetArea :: this -> ListenerDockWidgetArea
listenerDockWidgetArea_connectListener :: (ListenerDockWidgetAreaPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerDockWidgetArea_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerDockWidgetArea arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerDockWidgetArea_connectListener' arg'1' arg'2' arg'3')
data ListenerDockWidgetAreaConst =
ListenerDockWidgetAreaConst (HoppyF.Ptr ListenerDockWidgetAreaConst)
| ListenerDockWidgetAreaConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDockWidgetAreaConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDockWidgetAreaConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDockWidgetAreaConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDockWidgetAreaToConst :: ListenerDockWidgetArea -> ListenerDockWidgetAreaConst
castListenerDockWidgetAreaToConst (ListenerDockWidgetArea ptr') = ListenerDockWidgetAreaConst $ HoppyF.castPtr ptr'
castListenerDockWidgetAreaToConst (ListenerDockWidgetAreaGc fptr' ptr') = ListenerDockWidgetAreaConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDockWidgetAreaConst where
nullptr = ListenerDockWidgetAreaConst HoppyF.nullPtr
withCppPtr (ListenerDockWidgetAreaConst ptr') f' = f' ptr'
withCppPtr (ListenerDockWidgetAreaConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDockWidgetAreaConst ptr') = ptr'
toPtr (ListenerDockWidgetAreaConstGc _ ptr') = ptr'
touchCppPtr (ListenerDockWidgetAreaConst _) = HoppyP.return ()
touchCppPtr (ListenerDockWidgetAreaConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDockWidgetAreaConst where
delete (ListenerDockWidgetAreaConst ptr') = delete'ListenerDockWidgetArea ptr'
delete (ListenerDockWidgetAreaConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDockWidgetAreaConst", " object."]
toGc this'@(ListenerDockWidgetAreaConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDockWidgetAreaConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDockWidgetArea :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDockWidgetAreaConstGc {}) = HoppyP.return this'
instance ListenerDockWidgetAreaConstPtr ListenerDockWidgetAreaConst where
toListenerDockWidgetAreaConst = HoppyP.id
instance M34.QObjectConstPtr ListenerDockWidgetAreaConst where
toQObjectConst (ListenerDockWidgetAreaConst ptr') = M34.QObjectConst $ castListenerDockWidgetAreaToQObject ptr'
toQObjectConst (ListenerDockWidgetAreaConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDockWidgetAreaToQObject ptr'
data ListenerDockWidgetArea =
ListenerDockWidgetArea (HoppyF.Ptr ListenerDockWidgetArea)
| ListenerDockWidgetAreaGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDockWidgetArea)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDockWidgetArea where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDockWidgetArea where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDockWidgetAreaToNonconst :: ListenerDockWidgetAreaConst -> ListenerDockWidgetArea
castListenerDockWidgetAreaToNonconst (ListenerDockWidgetAreaConst ptr') = ListenerDockWidgetArea $ HoppyF.castPtr ptr'
castListenerDockWidgetAreaToNonconst (ListenerDockWidgetAreaConstGc fptr' ptr') = ListenerDockWidgetAreaGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDockWidgetArea where
nullptr = ListenerDockWidgetArea HoppyF.nullPtr
withCppPtr (ListenerDockWidgetArea ptr') f' = f' ptr'
withCppPtr (ListenerDockWidgetAreaGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDockWidgetArea ptr') = ptr'
toPtr (ListenerDockWidgetAreaGc _ ptr') = ptr'
touchCppPtr (ListenerDockWidgetArea _) = HoppyP.return ()
touchCppPtr (ListenerDockWidgetAreaGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDockWidgetArea where
delete (ListenerDockWidgetArea ptr') = delete'ListenerDockWidgetArea $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerDockWidgetAreaConst)
delete (ListenerDockWidgetAreaGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDockWidgetArea", " object."]
toGc this'@(ListenerDockWidgetArea ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDockWidgetAreaGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDockWidgetArea :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDockWidgetAreaGc {}) = HoppyP.return this'
instance ListenerDockWidgetAreaConstPtr ListenerDockWidgetArea where
toListenerDockWidgetAreaConst (ListenerDockWidgetArea ptr') = ListenerDockWidgetAreaConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
toListenerDockWidgetAreaConst (ListenerDockWidgetAreaGc fptr' ptr') = ListenerDockWidgetAreaConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
instance ListenerDockWidgetAreaPtr ListenerDockWidgetArea where
toListenerDockWidgetArea = HoppyP.id
instance M34.QObjectConstPtr ListenerDockWidgetArea where
toQObjectConst (ListenerDockWidgetArea ptr') = M34.QObjectConst $ castListenerDockWidgetAreaToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
toQObjectConst (ListenerDockWidgetAreaGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDockWidgetAreaToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
instance M34.QObjectPtr ListenerDockWidgetArea where
toQObject (ListenerDockWidgetArea ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDockWidgetAreaToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
toQObject (ListenerDockWidgetAreaGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDockWidgetAreaToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetArea -> HoppyF.Ptr ListenerDockWidgetAreaConst) ptr'
listenerDockWidgetArea_new :: (M68.QtDockWidgetArea -> HoppyP.IO ()) -> HoppyP.IO ListenerDockWidgetArea
listenerDockWidgetArea_new arg'1 =
M182.callbackDockWidgetAreaVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerDockWidgetArea
(listenerDockWidgetArea_new' arg'1')
listenerDockWidgetArea_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtDockWidgetArea -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerDockWidgetArea
listenerDockWidgetArea_newWithParent arg'1 arg'2 =
M182.callbackDockWidgetAreaVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerDockWidgetArea
(listenerDockWidgetArea_newWithParent' arg'1' arg'2')
class ListenerDockWidgetAreaSuper a where
downToListenerDockWidgetArea :: a -> ListenerDockWidgetArea
instance ListenerDockWidgetAreaSuper M34.QObject where
downToListenerDockWidgetArea = castListenerDockWidgetAreaToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerDockWidgetAreaConst $ castQObjectToListenerDockWidgetArea ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDockWidgetAreaConstGc fptr' $ castQObjectToListenerDockWidgetArea ptr'
class ListenerDockWidgetAreaSuperConst a where
downToListenerDockWidgetAreaConst :: a -> ListenerDockWidgetAreaConst
instance ListenerDockWidgetAreaSuperConst M34.QObjectConst where
downToListenerDockWidgetAreaConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerDockWidgetAreaConst $ castQObjectToListenerDockWidgetArea ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDockWidgetAreaConstGc fptr' $ castQObjectToListenerDockWidgetArea ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerDockWidgetArea)) ListenerDockWidgetArea where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerDockWidgetArea)) ListenerDockWidgetArea where
decode = HoppyP.fmap ListenerDockWidgetArea . HoppyF.peek
class ListenerDockWidgetAreasValue a where
withListenerDockWidgetAreasPtr :: a -> (ListenerDockWidgetAreasConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerDockWidgetAreasConstPtr a => ListenerDockWidgetAreasValue a where
withListenerDockWidgetAreasPtr = HoppyP.flip ($) . toListenerDockWidgetAreasConst
class (M34.QObjectConstPtr this) => ListenerDockWidgetAreasConstPtr this where
toListenerDockWidgetAreasConst :: this -> ListenerDockWidgetAreasConst
class (ListenerDockWidgetAreasConstPtr this, M34.QObjectPtr this) => ListenerDockWidgetAreasPtr this where
toListenerDockWidgetAreas :: this -> ListenerDockWidgetAreas
listenerDockWidgetAreas_connectListener :: (ListenerDockWidgetAreasPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerDockWidgetAreas_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerDockWidgetAreas arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerDockWidgetAreas_connectListener' arg'1' arg'2' arg'3')
data ListenerDockWidgetAreasConst =
ListenerDockWidgetAreasConst (HoppyF.Ptr ListenerDockWidgetAreasConst)
| ListenerDockWidgetAreasConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDockWidgetAreasConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDockWidgetAreasConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDockWidgetAreasConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDockWidgetAreasToConst :: ListenerDockWidgetAreas -> ListenerDockWidgetAreasConst
castListenerDockWidgetAreasToConst (ListenerDockWidgetAreas ptr') = ListenerDockWidgetAreasConst $ HoppyF.castPtr ptr'
castListenerDockWidgetAreasToConst (ListenerDockWidgetAreasGc fptr' ptr') = ListenerDockWidgetAreasConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDockWidgetAreasConst where
nullptr = ListenerDockWidgetAreasConst HoppyF.nullPtr
withCppPtr (ListenerDockWidgetAreasConst ptr') f' = f' ptr'
withCppPtr (ListenerDockWidgetAreasConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDockWidgetAreasConst ptr') = ptr'
toPtr (ListenerDockWidgetAreasConstGc _ ptr') = ptr'
touchCppPtr (ListenerDockWidgetAreasConst _) = HoppyP.return ()
touchCppPtr (ListenerDockWidgetAreasConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDockWidgetAreasConst where
delete (ListenerDockWidgetAreasConst ptr') = delete'ListenerDockWidgetAreas ptr'
delete (ListenerDockWidgetAreasConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDockWidgetAreasConst", " object."]
toGc this'@(ListenerDockWidgetAreasConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDockWidgetAreasConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDockWidgetAreas :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDockWidgetAreasConstGc {}) = HoppyP.return this'
instance ListenerDockWidgetAreasConstPtr ListenerDockWidgetAreasConst where
toListenerDockWidgetAreasConst = HoppyP.id
instance M34.QObjectConstPtr ListenerDockWidgetAreasConst where
toQObjectConst (ListenerDockWidgetAreasConst ptr') = M34.QObjectConst $ castListenerDockWidgetAreasToQObject ptr'
toQObjectConst (ListenerDockWidgetAreasConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDockWidgetAreasToQObject ptr'
data ListenerDockWidgetAreas =
ListenerDockWidgetAreas (HoppyF.Ptr ListenerDockWidgetAreas)
| ListenerDockWidgetAreasGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDockWidgetAreas)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDockWidgetAreas where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDockWidgetAreas where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDockWidgetAreasToNonconst :: ListenerDockWidgetAreasConst -> ListenerDockWidgetAreas
castListenerDockWidgetAreasToNonconst (ListenerDockWidgetAreasConst ptr') = ListenerDockWidgetAreas $ HoppyF.castPtr ptr'
castListenerDockWidgetAreasToNonconst (ListenerDockWidgetAreasConstGc fptr' ptr') = ListenerDockWidgetAreasGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDockWidgetAreas where
nullptr = ListenerDockWidgetAreas HoppyF.nullPtr
withCppPtr (ListenerDockWidgetAreas ptr') f' = f' ptr'
withCppPtr (ListenerDockWidgetAreasGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDockWidgetAreas ptr') = ptr'
toPtr (ListenerDockWidgetAreasGc _ ptr') = ptr'
touchCppPtr (ListenerDockWidgetAreas _) = HoppyP.return ()
touchCppPtr (ListenerDockWidgetAreasGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDockWidgetAreas where
delete (ListenerDockWidgetAreas ptr') = delete'ListenerDockWidgetAreas $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerDockWidgetAreasConst)
delete (ListenerDockWidgetAreasGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDockWidgetAreas", " object."]
toGc this'@(ListenerDockWidgetAreas ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDockWidgetAreasGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDockWidgetAreas :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDockWidgetAreasGc {}) = HoppyP.return this'
instance ListenerDockWidgetAreasConstPtr ListenerDockWidgetAreas where
toListenerDockWidgetAreasConst (ListenerDockWidgetAreas ptr') = ListenerDockWidgetAreasConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
toListenerDockWidgetAreasConst (ListenerDockWidgetAreasGc fptr' ptr') = ListenerDockWidgetAreasConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
instance ListenerDockWidgetAreasPtr ListenerDockWidgetAreas where
toListenerDockWidgetAreas = HoppyP.id
instance M34.QObjectConstPtr ListenerDockWidgetAreas where
toQObjectConst (ListenerDockWidgetAreas ptr') = M34.QObjectConst $ castListenerDockWidgetAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
toQObjectConst (ListenerDockWidgetAreasGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDockWidgetAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
instance M34.QObjectPtr ListenerDockWidgetAreas where
toQObject (ListenerDockWidgetAreas ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDockWidgetAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
toQObject (ListenerDockWidgetAreasGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDockWidgetAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDockWidgetAreas -> HoppyF.Ptr ListenerDockWidgetAreasConst) ptr'
listenerDockWidgetAreas_new :: (M68.QtDockWidgetAreas -> HoppyP.IO ()) -> HoppyP.IO ListenerDockWidgetAreas
listenerDockWidgetAreas_new arg'1 =
M182.callbackDockWidgetAreasVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerDockWidgetAreas
(listenerDockWidgetAreas_new' arg'1')
listenerDockWidgetAreas_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtDockWidgetAreas -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerDockWidgetAreas
listenerDockWidgetAreas_newWithParent arg'1 arg'2 =
M182.callbackDockWidgetAreasVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerDockWidgetAreas
(listenerDockWidgetAreas_newWithParent' arg'1' arg'2')
class ListenerDockWidgetAreasSuper a where
downToListenerDockWidgetAreas :: a -> ListenerDockWidgetAreas
instance ListenerDockWidgetAreasSuper M34.QObject where
downToListenerDockWidgetAreas = castListenerDockWidgetAreasToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerDockWidgetAreasConst $ castQObjectToListenerDockWidgetAreas ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDockWidgetAreasConstGc fptr' $ castQObjectToListenerDockWidgetAreas ptr'
class ListenerDockWidgetAreasSuperConst a where
downToListenerDockWidgetAreasConst :: a -> ListenerDockWidgetAreasConst
instance ListenerDockWidgetAreasSuperConst M34.QObjectConst where
downToListenerDockWidgetAreasConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerDockWidgetAreasConst $ castQObjectToListenerDockWidgetAreas ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDockWidgetAreasConstGc fptr' $ castQObjectToListenerDockWidgetAreas ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerDockWidgetAreas)) ListenerDockWidgetAreas where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerDockWidgetAreas)) ListenerDockWidgetAreas where
decode = HoppyP.fmap ListenerDockWidgetAreas . HoppyF.peek
class ListenerDoubleValue a where
withListenerDoublePtr :: a -> (ListenerDoubleConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerDoubleConstPtr a => ListenerDoubleValue a where
withListenerDoublePtr = HoppyP.flip ($) . toListenerDoubleConst
class (M34.QObjectConstPtr this) => ListenerDoubleConstPtr this where
toListenerDoubleConst :: this -> ListenerDoubleConst
class (ListenerDoubleConstPtr this, M34.QObjectPtr this) => ListenerDoublePtr this where
toListenerDouble :: this -> ListenerDouble
listenerDouble_connectListener :: (ListenerDoublePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerDouble_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerDouble arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerDouble_connectListener' arg'1' arg'2' arg'3')
data ListenerDoubleConst =
ListenerDoubleConst (HoppyF.Ptr ListenerDoubleConst)
| ListenerDoubleConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDoubleConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDoubleConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDoubleConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDoubleToConst :: ListenerDouble -> ListenerDoubleConst
castListenerDoubleToConst (ListenerDouble ptr') = ListenerDoubleConst $ HoppyF.castPtr ptr'
castListenerDoubleToConst (ListenerDoubleGc fptr' ptr') = ListenerDoubleConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDoubleConst where
nullptr = ListenerDoubleConst HoppyF.nullPtr
withCppPtr (ListenerDoubleConst ptr') f' = f' ptr'
withCppPtr (ListenerDoubleConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDoubleConst ptr') = ptr'
toPtr (ListenerDoubleConstGc _ ptr') = ptr'
touchCppPtr (ListenerDoubleConst _) = HoppyP.return ()
touchCppPtr (ListenerDoubleConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDoubleConst where
delete (ListenerDoubleConst ptr') = delete'ListenerDouble ptr'
delete (ListenerDoubleConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDoubleConst", " object."]
toGc this'@(ListenerDoubleConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDoubleConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDouble :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDoubleConstGc {}) = HoppyP.return this'
instance ListenerDoubleConstPtr ListenerDoubleConst where
toListenerDoubleConst = HoppyP.id
instance M34.QObjectConstPtr ListenerDoubleConst where
toQObjectConst (ListenerDoubleConst ptr') = M34.QObjectConst $ castListenerDoubleToQObject ptr'
toQObjectConst (ListenerDoubleConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDoubleToQObject ptr'
data ListenerDouble =
ListenerDouble (HoppyF.Ptr ListenerDouble)
| ListenerDoubleGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerDouble)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerDouble where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerDouble where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerDoubleToNonconst :: ListenerDoubleConst -> ListenerDouble
castListenerDoubleToNonconst (ListenerDoubleConst ptr') = ListenerDouble $ HoppyF.castPtr ptr'
castListenerDoubleToNonconst (ListenerDoubleConstGc fptr' ptr') = ListenerDoubleGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerDouble where
nullptr = ListenerDouble HoppyF.nullPtr
withCppPtr (ListenerDouble ptr') f' = f' ptr'
withCppPtr (ListenerDoubleGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerDouble ptr') = ptr'
toPtr (ListenerDoubleGc _ ptr') = ptr'
touchCppPtr (ListenerDouble _) = HoppyP.return ()
touchCppPtr (ListenerDoubleGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerDouble where
delete (ListenerDouble ptr') = delete'ListenerDouble $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerDoubleConst)
delete (ListenerDoubleGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerDouble", " object."]
toGc this'@(ListenerDouble ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerDoubleGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerDouble :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerDoubleGc {}) = HoppyP.return this'
instance ListenerDoubleConstPtr ListenerDouble where
toListenerDoubleConst (ListenerDouble ptr') = ListenerDoubleConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
toListenerDoubleConst (ListenerDoubleGc fptr' ptr') = ListenerDoubleConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
instance ListenerDoublePtr ListenerDouble where
toListenerDouble = HoppyP.id
instance M34.QObjectConstPtr ListenerDouble where
toQObjectConst (ListenerDouble ptr') = M34.QObjectConst $ castListenerDoubleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
toQObjectConst (ListenerDoubleGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerDoubleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
instance M34.QObjectPtr ListenerDouble where
toQObject (ListenerDouble ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDoubleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
toQObject (ListenerDoubleGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerDoubleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerDouble -> HoppyF.Ptr ListenerDoubleConst) ptr'
listenerDouble_new :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO ListenerDouble
listenerDouble_new arg'1 =
M182.callbackDoubleVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerDouble
(listenerDouble_new' arg'1')
listenerDouble_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Double -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerDouble
listenerDouble_newWithParent arg'1 arg'2 =
M182.callbackDoubleVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerDouble
(listenerDouble_newWithParent' arg'1' arg'2')
class ListenerDoubleSuper a where
downToListenerDouble :: a -> ListenerDouble
instance ListenerDoubleSuper M34.QObject where
downToListenerDouble = castListenerDoubleToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerDoubleConst $ castQObjectToListenerDouble ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDoubleConstGc fptr' $ castQObjectToListenerDouble ptr'
class ListenerDoubleSuperConst a where
downToListenerDoubleConst :: a -> ListenerDoubleConst
instance ListenerDoubleSuperConst M34.QObjectConst where
downToListenerDoubleConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerDoubleConst $ castQObjectToListenerDouble ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerDoubleConstGc fptr' $ castQObjectToListenerDouble ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerDouble)) ListenerDouble where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerDouble)) ListenerDouble where
decode = HoppyP.fmap ListenerDouble . HoppyF.peek
class ListenerIntValue a where
withListenerIntPtr :: a -> (ListenerIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerIntConstPtr a => ListenerIntValue a where
withListenerIntPtr = HoppyP.flip ($) . toListenerIntConst
class (M34.QObjectConstPtr this) => ListenerIntConstPtr this where
toListenerIntConst :: this -> ListenerIntConst
class (ListenerIntConstPtr this, M34.QObjectPtr this) => ListenerIntPtr this where
toListenerInt :: this -> ListenerInt
listenerInt_connectListener :: (ListenerIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerInt_connectListener' arg'1' arg'2' arg'3')
data ListenerIntConst =
ListenerIntConst (HoppyF.Ptr ListenerIntConst)
| ListenerIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntToConst :: ListenerInt -> ListenerIntConst
castListenerIntToConst (ListenerInt ptr') = ListenerIntConst $ HoppyF.castPtr ptr'
castListenerIntToConst (ListenerIntGc fptr' ptr') = ListenerIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerIntConst where
nullptr = ListenerIntConst HoppyF.nullPtr
withCppPtr (ListenerIntConst ptr') f' = f' ptr'
withCppPtr (ListenerIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerIntConst ptr') = ptr'
toPtr (ListenerIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerIntConst _) = HoppyP.return ()
touchCppPtr (ListenerIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerIntConst where
delete (ListenerIntConst ptr') = delete'ListenerInt ptr'
delete (ListenerIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerIntConst", " object."]
toGc this'@(ListenerIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntConstGc {}) = HoppyP.return this'
instance ListenerIntConstPtr ListenerIntConst where
toListenerIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerIntConst where
toQObjectConst (ListenerIntConst ptr') = M34.QObjectConst $ castListenerIntToQObject ptr'
toQObjectConst (ListenerIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntToQObject ptr'
data ListenerInt =
ListenerInt (HoppyF.Ptr ListenerInt)
| ListenerIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntToNonconst :: ListenerIntConst -> ListenerInt
castListenerIntToNonconst (ListenerIntConst ptr') = ListenerInt $ HoppyF.castPtr ptr'
castListenerIntToNonconst (ListenerIntConstGc fptr' ptr') = ListenerIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerInt where
nullptr = ListenerInt HoppyF.nullPtr
withCppPtr (ListenerInt ptr') f' = f' ptr'
withCppPtr (ListenerIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerInt ptr') = ptr'
toPtr (ListenerIntGc _ ptr') = ptr'
touchCppPtr (ListenerInt _) = HoppyP.return ()
touchCppPtr (ListenerIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerInt where
delete (ListenerInt ptr') = delete'ListenerInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerIntConst)
delete (ListenerIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerInt", " object."]
toGc this'@(ListenerInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntGc {}) = HoppyP.return this'
instance ListenerIntConstPtr ListenerInt where
toListenerIntConst (ListenerInt ptr') = ListenerIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
toListenerIntConst (ListenerIntGc fptr' ptr') = ListenerIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
instance ListenerIntPtr ListenerInt where
toListenerInt = HoppyP.id
instance M34.QObjectConstPtr ListenerInt where
toQObjectConst (ListenerInt ptr') = M34.QObjectConst $ castListenerIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
toQObjectConst (ListenerIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
instance M34.QObjectPtr ListenerInt where
toQObject (ListenerInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
toQObject (ListenerIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerInt -> HoppyF.Ptr ListenerIntConst) ptr'
listenerInt_new :: (HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO ListenerInt
listenerInt_new arg'1 =
M182.callbackIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerInt
(listenerInt_new' arg'1')
listenerInt_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Int -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerInt
listenerInt_newWithParent arg'1 arg'2 =
M182.callbackIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerInt
(listenerInt_newWithParent' arg'1' arg'2')
class ListenerIntSuper a where
downToListenerInt :: a -> ListenerInt
instance ListenerIntSuper M34.QObject where
downToListenerInt = castListenerIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerIntConst $ castQObjectToListenerInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntConstGc fptr' $ castQObjectToListenerInt ptr'
class ListenerIntSuperConst a where
downToListenerIntConst :: a -> ListenerIntConst
instance ListenerIntSuperConst M34.QObjectConst where
downToListenerIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerIntConst $ castQObjectToListenerInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntConstGc fptr' $ castQObjectToListenerInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerInt)) ListenerInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerInt)) ListenerInt where
decode = HoppyP.fmap ListenerInt . HoppyF.peek
class ListenerIntBoolValue a where
withListenerIntBoolPtr :: a -> (ListenerIntBoolConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerIntBoolConstPtr a => ListenerIntBoolValue a where
withListenerIntBoolPtr = HoppyP.flip ($) . toListenerIntBoolConst
class (M34.QObjectConstPtr this) => ListenerIntBoolConstPtr this where
toListenerIntBoolConst :: this -> ListenerIntBoolConst
class (ListenerIntBoolConstPtr this, M34.QObjectPtr this) => ListenerIntBoolPtr this where
toListenerIntBool :: this -> ListenerIntBool
listenerIntBool_connectListener :: (ListenerIntBoolPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerIntBool_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerIntBool arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerIntBool_connectListener' arg'1' arg'2' arg'3')
data ListenerIntBoolConst =
ListenerIntBoolConst (HoppyF.Ptr ListenerIntBoolConst)
| ListenerIntBoolConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerIntBoolConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerIntBoolConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerIntBoolConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntBoolToConst :: ListenerIntBool -> ListenerIntBoolConst
castListenerIntBoolToConst (ListenerIntBool ptr') = ListenerIntBoolConst $ HoppyF.castPtr ptr'
castListenerIntBoolToConst (ListenerIntBoolGc fptr' ptr') = ListenerIntBoolConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerIntBoolConst where
nullptr = ListenerIntBoolConst HoppyF.nullPtr
withCppPtr (ListenerIntBoolConst ptr') f' = f' ptr'
withCppPtr (ListenerIntBoolConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerIntBoolConst ptr') = ptr'
toPtr (ListenerIntBoolConstGc _ ptr') = ptr'
touchCppPtr (ListenerIntBoolConst _) = HoppyP.return ()
touchCppPtr (ListenerIntBoolConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerIntBoolConst where
delete (ListenerIntBoolConst ptr') = delete'ListenerIntBool ptr'
delete (ListenerIntBoolConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerIntBoolConst", " object."]
toGc this'@(ListenerIntBoolConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntBoolConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerIntBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntBoolConstGc {}) = HoppyP.return this'
instance ListenerIntBoolConstPtr ListenerIntBoolConst where
toListenerIntBoolConst = HoppyP.id
instance M34.QObjectConstPtr ListenerIntBoolConst where
toQObjectConst (ListenerIntBoolConst ptr') = M34.QObjectConst $ castListenerIntBoolToQObject ptr'
toQObjectConst (ListenerIntBoolConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntBoolToQObject ptr'
data ListenerIntBool =
ListenerIntBool (HoppyF.Ptr ListenerIntBool)
| ListenerIntBoolGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerIntBool)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerIntBool where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerIntBool where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntBoolToNonconst :: ListenerIntBoolConst -> ListenerIntBool
castListenerIntBoolToNonconst (ListenerIntBoolConst ptr') = ListenerIntBool $ HoppyF.castPtr ptr'
castListenerIntBoolToNonconst (ListenerIntBoolConstGc fptr' ptr') = ListenerIntBoolGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerIntBool where
nullptr = ListenerIntBool HoppyF.nullPtr
withCppPtr (ListenerIntBool ptr') f' = f' ptr'
withCppPtr (ListenerIntBoolGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerIntBool ptr') = ptr'
toPtr (ListenerIntBoolGc _ ptr') = ptr'
touchCppPtr (ListenerIntBool _) = HoppyP.return ()
touchCppPtr (ListenerIntBoolGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerIntBool where
delete (ListenerIntBool ptr') = delete'ListenerIntBool $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerIntBoolConst)
delete (ListenerIntBoolGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerIntBool", " object."]
toGc this'@(ListenerIntBool ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntBoolGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerIntBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntBoolGc {}) = HoppyP.return this'
instance ListenerIntBoolConstPtr ListenerIntBool where
toListenerIntBoolConst (ListenerIntBool ptr') = ListenerIntBoolConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
toListenerIntBoolConst (ListenerIntBoolGc fptr' ptr') = ListenerIntBoolConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
instance ListenerIntBoolPtr ListenerIntBool where
toListenerIntBool = HoppyP.id
instance M34.QObjectConstPtr ListenerIntBool where
toQObjectConst (ListenerIntBool ptr') = M34.QObjectConst $ castListenerIntBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
toQObjectConst (ListenerIntBoolGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
instance M34.QObjectPtr ListenerIntBool where
toQObject (ListenerIntBool ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
toQObject (ListenerIntBoolGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntBool -> HoppyF.Ptr ListenerIntBoolConst) ptr'
listenerIntBool_new :: (HoppyP.Int -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO ListenerIntBool
listenerIntBool_new arg'1 =
M182.callbackIntBoolVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerIntBool
(listenerIntBool_new' arg'1')
listenerIntBool_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Int -> HoppyP.Bool -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerIntBool
listenerIntBool_newWithParent arg'1 arg'2 =
M182.callbackIntBoolVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerIntBool
(listenerIntBool_newWithParent' arg'1' arg'2')
class ListenerIntBoolSuper a where
downToListenerIntBool :: a -> ListenerIntBool
instance ListenerIntBoolSuper M34.QObject where
downToListenerIntBool = castListenerIntBoolToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerIntBoolConst $ castQObjectToListenerIntBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntBoolConstGc fptr' $ castQObjectToListenerIntBool ptr'
class ListenerIntBoolSuperConst a where
downToListenerIntBoolConst :: a -> ListenerIntBoolConst
instance ListenerIntBoolSuperConst M34.QObjectConst where
downToListenerIntBoolConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerIntBoolConst $ castQObjectToListenerIntBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntBoolConstGc fptr' $ castQObjectToListenerIntBool ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerIntBool)) ListenerIntBool where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerIntBool)) ListenerIntBool where
decode = HoppyP.fmap ListenerIntBool . HoppyF.peek
class ListenerIntIntValue a where
withListenerIntIntPtr :: a -> (ListenerIntIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerIntIntConstPtr a => ListenerIntIntValue a where
withListenerIntIntPtr = HoppyP.flip ($) . toListenerIntIntConst
class (M34.QObjectConstPtr this) => ListenerIntIntConstPtr this where
toListenerIntIntConst :: this -> ListenerIntIntConst
class (ListenerIntIntConstPtr this, M34.QObjectPtr this) => ListenerIntIntPtr this where
toListenerIntInt :: this -> ListenerIntInt
listenerIntInt_connectListener :: (ListenerIntIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerIntInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerIntInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerIntInt_connectListener' arg'1' arg'2' arg'3')
data ListenerIntIntConst =
ListenerIntIntConst (HoppyF.Ptr ListenerIntIntConst)
| ListenerIntIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerIntIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerIntIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerIntIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntIntToConst :: ListenerIntInt -> ListenerIntIntConst
castListenerIntIntToConst (ListenerIntInt ptr') = ListenerIntIntConst $ HoppyF.castPtr ptr'
castListenerIntIntToConst (ListenerIntIntGc fptr' ptr') = ListenerIntIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerIntIntConst where
nullptr = ListenerIntIntConst HoppyF.nullPtr
withCppPtr (ListenerIntIntConst ptr') f' = f' ptr'
withCppPtr (ListenerIntIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerIntIntConst ptr') = ptr'
toPtr (ListenerIntIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerIntIntConst _) = HoppyP.return ()
touchCppPtr (ListenerIntIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerIntIntConst where
delete (ListenerIntIntConst ptr') = delete'ListenerIntInt ptr'
delete (ListenerIntIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerIntIntConst", " object."]
toGc this'@(ListenerIntIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerIntInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntIntConstGc {}) = HoppyP.return this'
instance ListenerIntIntConstPtr ListenerIntIntConst where
toListenerIntIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerIntIntConst where
toQObjectConst (ListenerIntIntConst ptr') = M34.QObjectConst $ castListenerIntIntToQObject ptr'
toQObjectConst (ListenerIntIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntIntToQObject ptr'
data ListenerIntInt =
ListenerIntInt (HoppyF.Ptr ListenerIntInt)
| ListenerIntIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerIntInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerIntInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerIntInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerIntIntToNonconst :: ListenerIntIntConst -> ListenerIntInt
castListenerIntIntToNonconst (ListenerIntIntConst ptr') = ListenerIntInt $ HoppyF.castPtr ptr'
castListenerIntIntToNonconst (ListenerIntIntConstGc fptr' ptr') = ListenerIntIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerIntInt where
nullptr = ListenerIntInt HoppyF.nullPtr
withCppPtr (ListenerIntInt ptr') f' = f' ptr'
withCppPtr (ListenerIntIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerIntInt ptr') = ptr'
toPtr (ListenerIntIntGc _ ptr') = ptr'
touchCppPtr (ListenerIntInt _) = HoppyP.return ()
touchCppPtr (ListenerIntIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerIntInt where
delete (ListenerIntInt ptr') = delete'ListenerIntInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerIntIntConst)
delete (ListenerIntIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerIntInt", " object."]
toGc this'@(ListenerIntInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerIntIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerIntInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerIntIntGc {}) = HoppyP.return this'
instance ListenerIntIntConstPtr ListenerIntInt where
toListenerIntIntConst (ListenerIntInt ptr') = ListenerIntIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
toListenerIntIntConst (ListenerIntIntGc fptr' ptr') = ListenerIntIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
instance ListenerIntIntPtr ListenerIntInt where
toListenerIntInt = HoppyP.id
instance M34.QObjectConstPtr ListenerIntInt where
toQObjectConst (ListenerIntInt ptr') = M34.QObjectConst $ castListenerIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
toQObjectConst (ListenerIntIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
instance M34.QObjectPtr ListenerIntInt where
toQObject (ListenerIntInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
toQObject (ListenerIntIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerIntInt -> HoppyF.Ptr ListenerIntIntConst) ptr'
listenerIntInt_new :: (HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO ListenerIntInt
listenerIntInt_new arg'1 =
M182.callbackIntIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerIntInt
(listenerIntInt_new' arg'1')
listenerIntInt_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerIntInt
listenerIntInt_newWithParent arg'1 arg'2 =
M182.callbackIntIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerIntInt
(listenerIntInt_newWithParent' arg'1' arg'2')
class ListenerIntIntSuper a where
downToListenerIntInt :: a -> ListenerIntInt
instance ListenerIntIntSuper M34.QObject where
downToListenerIntInt = castListenerIntIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerIntIntConst $ castQObjectToListenerIntInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntIntConstGc fptr' $ castQObjectToListenerIntInt ptr'
class ListenerIntIntSuperConst a where
downToListenerIntIntConst :: a -> ListenerIntIntConst
instance ListenerIntIntSuperConst M34.QObjectConst where
downToListenerIntIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerIntIntConst $ castQObjectToListenerIntInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerIntIntConstGc fptr' $ castQObjectToListenerIntInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerIntInt)) ListenerIntInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerIntInt)) ListenerIntInt where
decode = HoppyP.fmap ListenerIntInt . HoppyF.peek
class ListenerOrientationValue a where
withListenerOrientationPtr :: a -> (ListenerOrientationConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerOrientationConstPtr a => ListenerOrientationValue a where
withListenerOrientationPtr = HoppyP.flip ($) . toListenerOrientationConst
class (M34.QObjectConstPtr this) => ListenerOrientationConstPtr this where
toListenerOrientationConst :: this -> ListenerOrientationConst
class (ListenerOrientationConstPtr this, M34.QObjectPtr this) => ListenerOrientationPtr this where
toListenerOrientation :: this -> ListenerOrientation
listenerOrientation_connectListener :: (ListenerOrientationPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerOrientation_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerOrientation arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerOrientation_connectListener' arg'1' arg'2' arg'3')
data ListenerOrientationConst =
ListenerOrientationConst (HoppyF.Ptr ListenerOrientationConst)
| ListenerOrientationConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerOrientationConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerOrientationConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerOrientationConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerOrientationToConst :: ListenerOrientation -> ListenerOrientationConst
castListenerOrientationToConst (ListenerOrientation ptr') = ListenerOrientationConst $ HoppyF.castPtr ptr'
castListenerOrientationToConst (ListenerOrientationGc fptr' ptr') = ListenerOrientationConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerOrientationConst where
nullptr = ListenerOrientationConst HoppyF.nullPtr
withCppPtr (ListenerOrientationConst ptr') f' = f' ptr'
withCppPtr (ListenerOrientationConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerOrientationConst ptr') = ptr'
toPtr (ListenerOrientationConstGc _ ptr') = ptr'
touchCppPtr (ListenerOrientationConst _) = HoppyP.return ()
touchCppPtr (ListenerOrientationConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerOrientationConst where
delete (ListenerOrientationConst ptr') = delete'ListenerOrientation ptr'
delete (ListenerOrientationConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerOrientationConst", " object."]
toGc this'@(ListenerOrientationConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerOrientationConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerOrientation :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerOrientationConstGc {}) = HoppyP.return this'
instance ListenerOrientationConstPtr ListenerOrientationConst where
toListenerOrientationConst = HoppyP.id
instance M34.QObjectConstPtr ListenerOrientationConst where
toQObjectConst (ListenerOrientationConst ptr') = M34.QObjectConst $ castListenerOrientationToQObject ptr'
toQObjectConst (ListenerOrientationConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerOrientationToQObject ptr'
data ListenerOrientation =
ListenerOrientation (HoppyF.Ptr ListenerOrientation)
| ListenerOrientationGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerOrientation)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerOrientation where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerOrientation where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerOrientationToNonconst :: ListenerOrientationConst -> ListenerOrientation
castListenerOrientationToNonconst (ListenerOrientationConst ptr') = ListenerOrientation $ HoppyF.castPtr ptr'
castListenerOrientationToNonconst (ListenerOrientationConstGc fptr' ptr') = ListenerOrientationGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerOrientation where
nullptr = ListenerOrientation HoppyF.nullPtr
withCppPtr (ListenerOrientation ptr') f' = f' ptr'
withCppPtr (ListenerOrientationGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerOrientation ptr') = ptr'
toPtr (ListenerOrientationGc _ ptr') = ptr'
touchCppPtr (ListenerOrientation _) = HoppyP.return ()
touchCppPtr (ListenerOrientationGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerOrientation where
delete (ListenerOrientation ptr') = delete'ListenerOrientation $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerOrientationConst)
delete (ListenerOrientationGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerOrientation", " object."]
toGc this'@(ListenerOrientation ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerOrientationGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerOrientation :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerOrientationGc {}) = HoppyP.return this'
instance ListenerOrientationConstPtr ListenerOrientation where
toListenerOrientationConst (ListenerOrientation ptr') = ListenerOrientationConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
toListenerOrientationConst (ListenerOrientationGc fptr' ptr') = ListenerOrientationConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
instance ListenerOrientationPtr ListenerOrientation where
toListenerOrientation = HoppyP.id
instance M34.QObjectConstPtr ListenerOrientation where
toQObjectConst (ListenerOrientation ptr') = M34.QObjectConst $ castListenerOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
toQObjectConst (ListenerOrientationGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
instance M34.QObjectPtr ListenerOrientation where
toQObject (ListenerOrientation ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
toQObject (ListenerOrientationGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerOrientation -> HoppyF.Ptr ListenerOrientationConst) ptr'
listenerOrientation_new :: (M68.QtOrientation -> HoppyP.IO ()) -> HoppyP.IO ListenerOrientation
listenerOrientation_new arg'1 =
M182.callbackOrientationVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerOrientation
(listenerOrientation_new' arg'1')
listenerOrientation_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtOrientation -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerOrientation
listenerOrientation_newWithParent arg'1 arg'2 =
M182.callbackOrientationVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerOrientation
(listenerOrientation_newWithParent' arg'1' arg'2')
class ListenerOrientationSuper a where
downToListenerOrientation :: a -> ListenerOrientation
instance ListenerOrientationSuper M34.QObject where
downToListenerOrientation = castListenerOrientationToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerOrientationConst $ castQObjectToListenerOrientation ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerOrientationConstGc fptr' $ castQObjectToListenerOrientation ptr'
class ListenerOrientationSuperConst a where
downToListenerOrientationConst :: a -> ListenerOrientationConst
instance ListenerOrientationSuperConst M34.QObjectConst where
downToListenerOrientationConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerOrientationConst $ castQObjectToListenerOrientation ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerOrientationConstGc fptr' $ castQObjectToListenerOrientation ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerOrientation)) ListenerOrientation where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerOrientation)) ListenerOrientation where
decode = HoppyP.fmap ListenerOrientation . HoppyF.peek
class ListenerPtrQAbstractButtonValue a where
withListenerPtrQAbstractButtonPtr :: a -> (ListenerPtrQAbstractButtonConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQAbstractButtonConstPtr a => ListenerPtrQAbstractButtonValue a where
withListenerPtrQAbstractButtonPtr = HoppyP.flip ($) . toListenerPtrQAbstractButtonConst
class (M34.QObjectConstPtr this) => ListenerPtrQAbstractButtonConstPtr this where
toListenerPtrQAbstractButtonConst :: this -> ListenerPtrQAbstractButtonConst
class (ListenerPtrQAbstractButtonConstPtr this, M34.QObjectPtr this) => ListenerPtrQAbstractButtonPtr this where
toListenerPtrQAbstractButton :: this -> ListenerPtrQAbstractButton
listenerPtrQAbstractButton_connectListener :: (ListenerPtrQAbstractButtonPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQAbstractButton_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQAbstractButton arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQAbstractButton_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQAbstractButtonConst =
ListenerPtrQAbstractButtonConst (HoppyF.Ptr ListenerPtrQAbstractButtonConst)
| ListenerPtrQAbstractButtonConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractButtonConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractButtonConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractButtonConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractButtonToConst :: ListenerPtrQAbstractButton -> ListenerPtrQAbstractButtonConst
castListenerPtrQAbstractButtonToConst (ListenerPtrQAbstractButton ptr') = ListenerPtrQAbstractButtonConst $ HoppyF.castPtr ptr'
castListenerPtrQAbstractButtonToConst (ListenerPtrQAbstractButtonGc fptr' ptr') = ListenerPtrQAbstractButtonConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractButtonConst where
nullptr = ListenerPtrQAbstractButtonConst HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractButtonConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractButtonConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractButtonConst ptr') = ptr'
toPtr (ListenerPtrQAbstractButtonConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractButtonConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractButtonConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractButtonConst where
delete (ListenerPtrQAbstractButtonConst ptr') = delete'ListenerPtrQAbstractButton ptr'
delete (ListenerPtrQAbstractButtonConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractButtonConst", " object."]
toGc this'@(ListenerPtrQAbstractButtonConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractButtonConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractButton :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractButtonConstGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractButtonConstPtr ListenerPtrQAbstractButtonConst where
toListenerPtrQAbstractButtonConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractButtonConst where
toQObjectConst (ListenerPtrQAbstractButtonConst ptr') = M34.QObjectConst $ castListenerPtrQAbstractButtonToQObject ptr'
toQObjectConst (ListenerPtrQAbstractButtonConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractButtonToQObject ptr'
data ListenerPtrQAbstractButton =
ListenerPtrQAbstractButton (HoppyF.Ptr ListenerPtrQAbstractButton)
| ListenerPtrQAbstractButtonGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractButton)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractButton where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractButton where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractButtonToNonconst :: ListenerPtrQAbstractButtonConst -> ListenerPtrQAbstractButton
castListenerPtrQAbstractButtonToNonconst (ListenerPtrQAbstractButtonConst ptr') = ListenerPtrQAbstractButton $ HoppyF.castPtr ptr'
castListenerPtrQAbstractButtonToNonconst (ListenerPtrQAbstractButtonConstGc fptr' ptr') = ListenerPtrQAbstractButtonGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractButton where
nullptr = ListenerPtrQAbstractButton HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractButton ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractButtonGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractButton ptr') = ptr'
toPtr (ListenerPtrQAbstractButtonGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractButton _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractButtonGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractButton where
delete (ListenerPtrQAbstractButton ptr') = delete'ListenerPtrQAbstractButton $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQAbstractButtonConst)
delete (ListenerPtrQAbstractButtonGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractButton", " object."]
toGc this'@(ListenerPtrQAbstractButton ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractButtonGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractButton :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractButtonGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractButtonConstPtr ListenerPtrQAbstractButton where
toListenerPtrQAbstractButtonConst (ListenerPtrQAbstractButton ptr') = ListenerPtrQAbstractButtonConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
toListenerPtrQAbstractButtonConst (ListenerPtrQAbstractButtonGc fptr' ptr') = ListenerPtrQAbstractButtonConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
instance ListenerPtrQAbstractButtonPtr ListenerPtrQAbstractButton where
toListenerPtrQAbstractButton = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractButton where
toQObjectConst (ListenerPtrQAbstractButton ptr') = M34.QObjectConst $ castListenerPtrQAbstractButtonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
toQObjectConst (ListenerPtrQAbstractButtonGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractButtonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
instance M34.QObjectPtr ListenerPtrQAbstractButton where
toQObject (ListenerPtrQAbstractButton ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractButtonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
toQObject (ListenerPtrQAbstractButtonGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractButtonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButton -> HoppyF.Ptr ListenerPtrQAbstractButtonConst) ptr'
listenerPtrQAbstractButton_new :: (M188.QAbstractButton -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQAbstractButton
listenerPtrQAbstractButton_new arg'1 =
M182.callbackPtrQAbstractButtonVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQAbstractButton
(listenerPtrQAbstractButton_new' arg'1')
listenerPtrQAbstractButton_newWithParent :: (M34.QObjectPtr arg'2) => (M188.QAbstractButton -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQAbstractButton
listenerPtrQAbstractButton_newWithParent arg'1 arg'2 =
M182.callbackPtrQAbstractButtonVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQAbstractButton
(listenerPtrQAbstractButton_newWithParent' arg'1' arg'2')
class ListenerPtrQAbstractButtonSuper a where
downToListenerPtrQAbstractButton :: a -> ListenerPtrQAbstractButton
instance ListenerPtrQAbstractButtonSuper M34.QObject where
downToListenerPtrQAbstractButton = castListenerPtrQAbstractButtonToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractButtonConst $ castQObjectToListenerPtrQAbstractButton ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractButtonConstGc fptr' $ castQObjectToListenerPtrQAbstractButton ptr'
class ListenerPtrQAbstractButtonSuperConst a where
downToListenerPtrQAbstractButtonConst :: a -> ListenerPtrQAbstractButtonConst
instance ListenerPtrQAbstractButtonSuperConst M34.QObjectConst where
downToListenerPtrQAbstractButtonConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractButtonConst $ castQObjectToListenerPtrQAbstractButton ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractButtonConstGc fptr' $ castQObjectToListenerPtrQAbstractButton ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractButton)) ListenerPtrQAbstractButton where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractButton)) ListenerPtrQAbstractButton where
decode = HoppyP.fmap ListenerPtrQAbstractButton . HoppyF.peek
class ListenerPtrQAbstractButtonBoolValue a where
withListenerPtrQAbstractButtonBoolPtr :: a -> (ListenerPtrQAbstractButtonBoolConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQAbstractButtonBoolConstPtr a => ListenerPtrQAbstractButtonBoolValue a where
withListenerPtrQAbstractButtonBoolPtr = HoppyP.flip ($) . toListenerPtrQAbstractButtonBoolConst
class (M34.QObjectConstPtr this) => ListenerPtrQAbstractButtonBoolConstPtr this where
toListenerPtrQAbstractButtonBoolConst :: this -> ListenerPtrQAbstractButtonBoolConst
class (ListenerPtrQAbstractButtonBoolConstPtr this, M34.QObjectPtr this) => ListenerPtrQAbstractButtonBoolPtr this where
toListenerPtrQAbstractButtonBool :: this -> ListenerPtrQAbstractButtonBool
listenerPtrQAbstractButtonBool_connectListener :: (ListenerPtrQAbstractButtonBoolPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQAbstractButtonBool_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQAbstractButtonBool arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQAbstractButtonBool_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQAbstractButtonBoolConst =
ListenerPtrQAbstractButtonBoolConst (HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst)
| ListenerPtrQAbstractButtonBoolConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractButtonBoolConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractButtonBoolConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractButtonBoolToConst :: ListenerPtrQAbstractButtonBool -> ListenerPtrQAbstractButtonBoolConst
castListenerPtrQAbstractButtonBoolToConst (ListenerPtrQAbstractButtonBool ptr') = ListenerPtrQAbstractButtonBoolConst $ HoppyF.castPtr ptr'
castListenerPtrQAbstractButtonBoolToConst (ListenerPtrQAbstractButtonBoolGc fptr' ptr') = ListenerPtrQAbstractButtonBoolConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractButtonBoolConst where
nullptr = ListenerPtrQAbstractButtonBoolConst HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractButtonBoolConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractButtonBoolConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractButtonBoolConst ptr') = ptr'
toPtr (ListenerPtrQAbstractButtonBoolConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractButtonBoolConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractButtonBoolConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractButtonBoolConst where
delete (ListenerPtrQAbstractButtonBoolConst ptr') = delete'ListenerPtrQAbstractButtonBool ptr'
delete (ListenerPtrQAbstractButtonBoolConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractButtonBoolConst", " object."]
toGc this'@(ListenerPtrQAbstractButtonBoolConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractButtonBoolConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractButtonBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractButtonBoolConstGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractButtonBoolConstPtr ListenerPtrQAbstractButtonBoolConst where
toListenerPtrQAbstractButtonBoolConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractButtonBoolConst where
toQObjectConst (ListenerPtrQAbstractButtonBoolConst ptr') = M34.QObjectConst $ castListenerPtrQAbstractButtonBoolToQObject ptr'
toQObjectConst (ListenerPtrQAbstractButtonBoolConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractButtonBoolToQObject ptr'
data ListenerPtrQAbstractButtonBool =
ListenerPtrQAbstractButtonBool (HoppyF.Ptr ListenerPtrQAbstractButtonBool)
| ListenerPtrQAbstractButtonBoolGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractButtonBool)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractButtonBool where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractButtonBool where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractButtonBoolToNonconst :: ListenerPtrQAbstractButtonBoolConst -> ListenerPtrQAbstractButtonBool
castListenerPtrQAbstractButtonBoolToNonconst (ListenerPtrQAbstractButtonBoolConst ptr') = ListenerPtrQAbstractButtonBool $ HoppyF.castPtr ptr'
castListenerPtrQAbstractButtonBoolToNonconst (ListenerPtrQAbstractButtonBoolConstGc fptr' ptr') = ListenerPtrQAbstractButtonBoolGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractButtonBool where
nullptr = ListenerPtrQAbstractButtonBool HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractButtonBool ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractButtonBoolGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractButtonBool ptr') = ptr'
toPtr (ListenerPtrQAbstractButtonBoolGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractButtonBool _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractButtonBoolGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractButtonBool where
delete (ListenerPtrQAbstractButtonBool ptr') = delete'ListenerPtrQAbstractButtonBool $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst)
delete (ListenerPtrQAbstractButtonBoolGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractButtonBool", " object."]
toGc this'@(ListenerPtrQAbstractButtonBool ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractButtonBoolGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractButtonBool :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractButtonBoolGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractButtonBoolConstPtr ListenerPtrQAbstractButtonBool where
toListenerPtrQAbstractButtonBoolConst (ListenerPtrQAbstractButtonBool ptr') = ListenerPtrQAbstractButtonBoolConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
toListenerPtrQAbstractButtonBoolConst (ListenerPtrQAbstractButtonBoolGc fptr' ptr') = ListenerPtrQAbstractButtonBoolConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
instance ListenerPtrQAbstractButtonBoolPtr ListenerPtrQAbstractButtonBool where
toListenerPtrQAbstractButtonBool = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractButtonBool where
toQObjectConst (ListenerPtrQAbstractButtonBool ptr') = M34.QObjectConst $ castListenerPtrQAbstractButtonBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
toQObjectConst (ListenerPtrQAbstractButtonBoolGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractButtonBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
instance M34.QObjectPtr ListenerPtrQAbstractButtonBool where
toQObject (ListenerPtrQAbstractButtonBool ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractButtonBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
toQObject (ListenerPtrQAbstractButtonBoolGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractButtonBoolToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractButtonBool -> HoppyF.Ptr ListenerPtrQAbstractButtonBoolConst) ptr'
listenerPtrQAbstractButtonBool_new :: (M188.QAbstractButton -> HoppyP.Bool -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQAbstractButtonBool
listenerPtrQAbstractButtonBool_new arg'1 =
M182.callbackPtrQAbstractButtonBoolVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQAbstractButtonBool
(listenerPtrQAbstractButtonBool_new' arg'1')
listenerPtrQAbstractButtonBool_newWithParent :: (M34.QObjectPtr arg'2) => (M188.QAbstractButton -> HoppyP.Bool -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQAbstractButtonBool
listenerPtrQAbstractButtonBool_newWithParent arg'1 arg'2 =
M182.callbackPtrQAbstractButtonBoolVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQAbstractButtonBool
(listenerPtrQAbstractButtonBool_newWithParent' arg'1' arg'2')
class ListenerPtrQAbstractButtonBoolSuper a where
downToListenerPtrQAbstractButtonBool :: a -> ListenerPtrQAbstractButtonBool
instance ListenerPtrQAbstractButtonBoolSuper M34.QObject where
downToListenerPtrQAbstractButtonBool = castListenerPtrQAbstractButtonBoolToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractButtonBoolConst $ castQObjectToListenerPtrQAbstractButtonBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractButtonBoolConstGc fptr' $ castQObjectToListenerPtrQAbstractButtonBool ptr'
class ListenerPtrQAbstractButtonBoolSuperConst a where
downToListenerPtrQAbstractButtonBoolConst :: a -> ListenerPtrQAbstractButtonBoolConst
instance ListenerPtrQAbstractButtonBoolSuperConst M34.QObjectConst where
downToListenerPtrQAbstractButtonBoolConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractButtonBoolConst $ castQObjectToListenerPtrQAbstractButtonBool ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractButtonBoolConstGc fptr' $ castQObjectToListenerPtrQAbstractButtonBool ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractButtonBool)) ListenerPtrQAbstractButtonBool where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractButtonBool)) ListenerPtrQAbstractButtonBool where
decode = HoppyP.fmap ListenerPtrQAbstractButtonBool . HoppyF.peek
class ListenerPtrQAbstractItemModelValue a where
withListenerPtrQAbstractItemModelPtr :: a -> (ListenerPtrQAbstractItemModelConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQAbstractItemModelConstPtr a => ListenerPtrQAbstractItemModelValue a where
withListenerPtrQAbstractItemModelPtr = HoppyP.flip ($) . toListenerPtrQAbstractItemModelConst
class (M34.QObjectConstPtr this) => ListenerPtrQAbstractItemModelConstPtr this where
toListenerPtrQAbstractItemModelConst :: this -> ListenerPtrQAbstractItemModelConst
class (ListenerPtrQAbstractItemModelConstPtr this, M34.QObjectPtr this) => ListenerPtrQAbstractItemModelPtr this where
toListenerPtrQAbstractItemModel :: this -> ListenerPtrQAbstractItemModel
listenerPtrQAbstractItemModel_connectListener :: (ListenerPtrQAbstractItemModelPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQAbstractItemModel_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQAbstractItemModel arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQAbstractItemModel_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQAbstractItemModelConst =
ListenerPtrQAbstractItemModelConst (HoppyF.Ptr ListenerPtrQAbstractItemModelConst)
| ListenerPtrQAbstractItemModelConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractItemModelConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractItemModelConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractItemModelConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractItemModelToConst :: ListenerPtrQAbstractItemModel -> ListenerPtrQAbstractItemModelConst
castListenerPtrQAbstractItemModelToConst (ListenerPtrQAbstractItemModel ptr') = ListenerPtrQAbstractItemModelConst $ HoppyF.castPtr ptr'
castListenerPtrQAbstractItemModelToConst (ListenerPtrQAbstractItemModelGc fptr' ptr') = ListenerPtrQAbstractItemModelConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractItemModelConst where
nullptr = ListenerPtrQAbstractItemModelConst HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractItemModelConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractItemModelConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractItemModelConst ptr') = ptr'
toPtr (ListenerPtrQAbstractItemModelConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractItemModelConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractItemModelConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractItemModelConst where
delete (ListenerPtrQAbstractItemModelConst ptr') = delete'ListenerPtrQAbstractItemModel ptr'
delete (ListenerPtrQAbstractItemModelConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractItemModelConst", " object."]
toGc this'@(ListenerPtrQAbstractItemModelConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractItemModelConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractItemModel :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractItemModelConstGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractItemModelConstPtr ListenerPtrQAbstractItemModelConst where
toListenerPtrQAbstractItemModelConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractItemModelConst where
toQObjectConst (ListenerPtrQAbstractItemModelConst ptr') = M34.QObjectConst $ castListenerPtrQAbstractItemModelToQObject ptr'
toQObjectConst (ListenerPtrQAbstractItemModelConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractItemModelToQObject ptr'
data ListenerPtrQAbstractItemModel =
ListenerPtrQAbstractItemModel (HoppyF.Ptr ListenerPtrQAbstractItemModel)
| ListenerPtrQAbstractItemModelGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAbstractItemModel)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAbstractItemModel where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAbstractItemModel where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQAbstractItemModelToNonconst :: ListenerPtrQAbstractItemModelConst -> ListenerPtrQAbstractItemModel
castListenerPtrQAbstractItemModelToNonconst (ListenerPtrQAbstractItemModelConst ptr') = ListenerPtrQAbstractItemModel $ HoppyF.castPtr ptr'
castListenerPtrQAbstractItemModelToNonconst (ListenerPtrQAbstractItemModelConstGc fptr' ptr') = ListenerPtrQAbstractItemModelGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAbstractItemModel where
nullptr = ListenerPtrQAbstractItemModel HoppyF.nullPtr
withCppPtr (ListenerPtrQAbstractItemModel ptr') f' = f' ptr'
withCppPtr (ListenerPtrQAbstractItemModelGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAbstractItemModel ptr') = ptr'
toPtr (ListenerPtrQAbstractItemModelGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAbstractItemModel _) = HoppyP.return ()
touchCppPtr (ListenerPtrQAbstractItemModelGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAbstractItemModel where
delete (ListenerPtrQAbstractItemModel ptr') = delete'ListenerPtrQAbstractItemModel $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQAbstractItemModelConst)
delete (ListenerPtrQAbstractItemModelGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAbstractItemModel", " object."]
toGc this'@(ListenerPtrQAbstractItemModel ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQAbstractItemModelGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAbstractItemModel :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQAbstractItemModelGc {}) = HoppyP.return this'
instance ListenerPtrQAbstractItemModelConstPtr ListenerPtrQAbstractItemModel where
toListenerPtrQAbstractItemModelConst (ListenerPtrQAbstractItemModel ptr') = ListenerPtrQAbstractItemModelConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
toListenerPtrQAbstractItemModelConst (ListenerPtrQAbstractItemModelGc fptr' ptr') = ListenerPtrQAbstractItemModelConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
instance ListenerPtrQAbstractItemModelPtr ListenerPtrQAbstractItemModel where
toListenerPtrQAbstractItemModel = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAbstractItemModel where
toQObjectConst (ListenerPtrQAbstractItemModel ptr') = M34.QObjectConst $ castListenerPtrQAbstractItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
toQObjectConst (ListenerPtrQAbstractItemModelGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQAbstractItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
instance M34.QObjectPtr ListenerPtrQAbstractItemModel where
toQObject (ListenerPtrQAbstractItemModel ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
toQObject (ListenerPtrQAbstractItemModelGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQAbstractItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAbstractItemModel -> HoppyF.Ptr ListenerPtrQAbstractItemModelConst) ptr'
listenerPtrQAbstractItemModel_new :: (M2.QAbstractItemModel -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQAbstractItemModel
listenerPtrQAbstractItemModel_new arg'1 =
M182.callbackPtrQAbstractItemModelVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQAbstractItemModel
(listenerPtrQAbstractItemModel_new' arg'1')
listenerPtrQAbstractItemModel_newWithParent :: (M34.QObjectPtr arg'2) => (M2.QAbstractItemModel -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQAbstractItemModel
listenerPtrQAbstractItemModel_newWithParent arg'1 arg'2 =
M182.callbackPtrQAbstractItemModelVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQAbstractItemModel
(listenerPtrQAbstractItemModel_newWithParent' arg'1' arg'2')
class ListenerPtrQAbstractItemModelSuper a where
downToListenerPtrQAbstractItemModel :: a -> ListenerPtrQAbstractItemModel
instance ListenerPtrQAbstractItemModelSuper M34.QObject where
downToListenerPtrQAbstractItemModel = castListenerPtrQAbstractItemModelToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractItemModelConst $ castQObjectToListenerPtrQAbstractItemModel ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractItemModelConstGc fptr' $ castQObjectToListenerPtrQAbstractItemModel ptr'
class ListenerPtrQAbstractItemModelSuperConst a where
downToListenerPtrQAbstractItemModelConst :: a -> ListenerPtrQAbstractItemModelConst
instance ListenerPtrQAbstractItemModelSuperConst M34.QObjectConst where
downToListenerPtrQAbstractItemModelConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQAbstractItemModelConst $ castQObjectToListenerPtrQAbstractItemModel ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQAbstractItemModelConstGc fptr' $ castQObjectToListenerPtrQAbstractItemModel ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractItemModel)) ListenerPtrQAbstractItemModel where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAbstractItemModel)) ListenerPtrQAbstractItemModel where
decode = HoppyP.fmap ListenerPtrQAbstractItemModel . HoppyF.peek
class ListenerPtrQActionValue a where
withListenerPtrQActionPtr :: a -> (ListenerPtrQActionConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQActionConstPtr a => ListenerPtrQActionValue a where
withListenerPtrQActionPtr = HoppyP.flip ($) . toListenerPtrQActionConst
class (M34.QObjectConstPtr this) => ListenerPtrQActionConstPtr this where
toListenerPtrQActionConst :: this -> ListenerPtrQActionConst
class (ListenerPtrQActionConstPtr this, M34.QObjectPtr this) => ListenerPtrQActionPtr this where
toListenerPtrQAction :: this -> ListenerPtrQAction
listenerPtrQAction_connectListener :: (ListenerPtrQActionPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQAction_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQAction arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQAction_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQActionConst =
ListenerPtrQActionConst (HoppyF.Ptr ListenerPtrQActionConst)
| ListenerPtrQActionConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQActionConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQActionConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQActionConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQActionToConst :: ListenerPtrQAction -> ListenerPtrQActionConst
castListenerPtrQActionToConst (ListenerPtrQAction ptr') = ListenerPtrQActionConst $ HoppyF.castPtr ptr'
castListenerPtrQActionToConst (ListenerPtrQActionGc fptr' ptr') = ListenerPtrQActionConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQActionConst where
nullptr = ListenerPtrQActionConst HoppyF.nullPtr
withCppPtr (ListenerPtrQActionConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQActionConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQActionConst ptr') = ptr'
toPtr (ListenerPtrQActionConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQActionConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQActionConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQActionConst where
delete (ListenerPtrQActionConst ptr') = delete'ListenerPtrQAction ptr'
delete (ListenerPtrQActionConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQActionConst", " object."]
toGc this'@(ListenerPtrQActionConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQActionConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAction :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQActionConstGc {}) = HoppyP.return this'
instance ListenerPtrQActionConstPtr ListenerPtrQActionConst where
toListenerPtrQActionConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQActionConst where
toQObjectConst (ListenerPtrQActionConst ptr') = M34.QObjectConst $ castListenerPtrQActionToQObject ptr'
toQObjectConst (ListenerPtrQActionConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQActionToQObject ptr'
data ListenerPtrQAction =
ListenerPtrQAction (HoppyF.Ptr ListenerPtrQAction)
| ListenerPtrQActionGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQAction)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQAction where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQAction where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQActionToNonconst :: ListenerPtrQActionConst -> ListenerPtrQAction
castListenerPtrQActionToNonconst (ListenerPtrQActionConst ptr') = ListenerPtrQAction $ HoppyF.castPtr ptr'
castListenerPtrQActionToNonconst (ListenerPtrQActionConstGc fptr' ptr') = ListenerPtrQActionGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQAction where
nullptr = ListenerPtrQAction HoppyF.nullPtr
withCppPtr (ListenerPtrQAction ptr') f' = f' ptr'
withCppPtr (ListenerPtrQActionGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQAction ptr') = ptr'
toPtr (ListenerPtrQActionGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQAction _) = HoppyP.return ()
touchCppPtr (ListenerPtrQActionGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQAction where
delete (ListenerPtrQAction ptr') = delete'ListenerPtrQAction $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQActionConst)
delete (ListenerPtrQActionGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQAction", " object."]
toGc this'@(ListenerPtrQAction ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQActionGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQAction :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQActionGc {}) = HoppyP.return this'
instance ListenerPtrQActionConstPtr ListenerPtrQAction where
toListenerPtrQActionConst (ListenerPtrQAction ptr') = ListenerPtrQActionConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
toListenerPtrQActionConst (ListenerPtrQActionGc fptr' ptr') = ListenerPtrQActionConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
instance ListenerPtrQActionPtr ListenerPtrQAction where
toListenerPtrQAction = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQAction where
toQObjectConst (ListenerPtrQAction ptr') = M34.QObjectConst $ castListenerPtrQActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
toQObjectConst (ListenerPtrQActionGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
instance M34.QObjectPtr ListenerPtrQAction where
toQObject (ListenerPtrQAction ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
toQObject (ListenerPtrQActionGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQAction -> HoppyF.Ptr ListenerPtrQActionConst) ptr'
listenerPtrQAction_new :: (M202.QAction -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQAction
listenerPtrQAction_new arg'1 =
M182.callbackPtrQActionVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQAction
(listenerPtrQAction_new' arg'1')
listenerPtrQAction_newWithParent :: (M34.QObjectPtr arg'2) => (M202.QAction -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQAction
listenerPtrQAction_newWithParent arg'1 arg'2 =
M182.callbackPtrQActionVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQAction
(listenerPtrQAction_newWithParent' arg'1' arg'2')
class ListenerPtrQActionSuper a where
downToListenerPtrQAction :: a -> ListenerPtrQAction
instance ListenerPtrQActionSuper M34.QObject where
downToListenerPtrQAction = castListenerPtrQActionToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQActionConst $ castQObjectToListenerPtrQAction ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQActionConstGc fptr' $ castQObjectToListenerPtrQAction ptr'
class ListenerPtrQActionSuperConst a where
downToListenerPtrQActionConst :: a -> ListenerPtrQActionConst
instance ListenerPtrQActionSuperConst M34.QObjectConst where
downToListenerPtrQActionConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQActionConst $ castQObjectToListenerPtrQAction ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQActionConstGc fptr' $ castQObjectToListenerPtrQAction ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAction)) ListenerPtrQAction where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQAction)) ListenerPtrQAction where
decode = HoppyP.fmap ListenerPtrQAction . HoppyF.peek
class ListenerPtrQObjectValue a where
withListenerPtrQObjectPtr :: a -> (ListenerPtrQObjectConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQObjectConstPtr a => ListenerPtrQObjectValue a where
withListenerPtrQObjectPtr = HoppyP.flip ($) . toListenerPtrQObjectConst
class (M34.QObjectConstPtr this) => ListenerPtrQObjectConstPtr this where
toListenerPtrQObjectConst :: this -> ListenerPtrQObjectConst
class (ListenerPtrQObjectConstPtr this, M34.QObjectPtr this) => ListenerPtrQObjectPtr this where
toListenerPtrQObject :: this -> ListenerPtrQObject
listenerPtrQObject_connectListener :: (ListenerPtrQObjectPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQObject_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQObject arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQObject_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQObjectConst =
ListenerPtrQObjectConst (HoppyF.Ptr ListenerPtrQObjectConst)
| ListenerPtrQObjectConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQObjectConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQObjectConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQObjectConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQObjectToConst :: ListenerPtrQObject -> ListenerPtrQObjectConst
castListenerPtrQObjectToConst (ListenerPtrQObject ptr') = ListenerPtrQObjectConst $ HoppyF.castPtr ptr'
castListenerPtrQObjectToConst (ListenerPtrQObjectGc fptr' ptr') = ListenerPtrQObjectConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQObjectConst where
nullptr = ListenerPtrQObjectConst HoppyF.nullPtr
withCppPtr (ListenerPtrQObjectConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQObjectConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQObjectConst ptr') = ptr'
toPtr (ListenerPtrQObjectConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQObjectConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQObjectConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQObjectConst where
delete (ListenerPtrQObjectConst ptr') = delete'ListenerPtrQObject ptr'
delete (ListenerPtrQObjectConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQObjectConst", " object."]
toGc this'@(ListenerPtrQObjectConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQObjectConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQObject :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQObjectConstGc {}) = HoppyP.return this'
instance ListenerPtrQObjectConstPtr ListenerPtrQObjectConst where
toListenerPtrQObjectConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQObjectConst where
toQObjectConst (ListenerPtrQObjectConst ptr') = M34.QObjectConst $ castListenerPtrQObjectToQObject ptr'
toQObjectConst (ListenerPtrQObjectConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQObjectToQObject ptr'
data ListenerPtrQObject =
ListenerPtrQObject (HoppyF.Ptr ListenerPtrQObject)
| ListenerPtrQObjectGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQObject)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQObject where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQObject where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQObjectToNonconst :: ListenerPtrQObjectConst -> ListenerPtrQObject
castListenerPtrQObjectToNonconst (ListenerPtrQObjectConst ptr') = ListenerPtrQObject $ HoppyF.castPtr ptr'
castListenerPtrQObjectToNonconst (ListenerPtrQObjectConstGc fptr' ptr') = ListenerPtrQObjectGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQObject where
nullptr = ListenerPtrQObject HoppyF.nullPtr
withCppPtr (ListenerPtrQObject ptr') f' = f' ptr'
withCppPtr (ListenerPtrQObjectGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQObject ptr') = ptr'
toPtr (ListenerPtrQObjectGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQObject _) = HoppyP.return ()
touchCppPtr (ListenerPtrQObjectGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQObject where
delete (ListenerPtrQObject ptr') = delete'ListenerPtrQObject $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQObjectConst)
delete (ListenerPtrQObjectGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQObject", " object."]
toGc this'@(ListenerPtrQObject ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQObjectGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQObject :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQObjectGc {}) = HoppyP.return this'
instance ListenerPtrQObjectConstPtr ListenerPtrQObject where
toListenerPtrQObjectConst (ListenerPtrQObject ptr') = ListenerPtrQObjectConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
toListenerPtrQObjectConst (ListenerPtrQObjectGc fptr' ptr') = ListenerPtrQObjectConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
instance ListenerPtrQObjectPtr ListenerPtrQObject where
toListenerPtrQObject = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQObject where
toQObjectConst (ListenerPtrQObject ptr') = M34.QObjectConst $ castListenerPtrQObjectToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
toQObjectConst (ListenerPtrQObjectGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQObjectToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
instance M34.QObjectPtr ListenerPtrQObject where
toQObject (ListenerPtrQObject ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQObjectToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
toQObject (ListenerPtrQObjectGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQObjectToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQObject -> HoppyF.Ptr ListenerPtrQObjectConst) ptr'
listenerPtrQObject_new :: (M34.QObject -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQObject
listenerPtrQObject_new arg'1 =
M182.callbackPtrQObjectVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQObject
(listenerPtrQObject_new' arg'1')
listenerPtrQObject_newWithParent :: (M34.QObjectPtr arg'2) => (M34.QObject -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQObject
listenerPtrQObject_newWithParent arg'1 arg'2 =
M182.callbackPtrQObjectVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQObject
(listenerPtrQObject_newWithParent' arg'1' arg'2')
class ListenerPtrQObjectSuper a where
downToListenerPtrQObject :: a -> ListenerPtrQObject
instance ListenerPtrQObjectSuper M34.QObject where
downToListenerPtrQObject = castListenerPtrQObjectToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQObjectConst $ castQObjectToListenerPtrQObject ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQObjectConstGc fptr' $ castQObjectToListenerPtrQObject ptr'
class ListenerPtrQObjectSuperConst a where
downToListenerPtrQObjectConst :: a -> ListenerPtrQObjectConst
instance ListenerPtrQObjectSuperConst M34.QObjectConst where
downToListenerPtrQObjectConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQObjectConst $ castQObjectToListenerPtrQObject ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQObjectConstGc fptr' $ castQObjectToListenerPtrQObject ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQObject)) ListenerPtrQObject where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQObject)) ListenerPtrQObject where
decode = HoppyP.fmap ListenerPtrQObject . HoppyF.peek
class ListenerPtrQTreeWidgetItemValue a where
withListenerPtrQTreeWidgetItemPtr :: a -> (ListenerPtrQTreeWidgetItemConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQTreeWidgetItemConstPtr a => ListenerPtrQTreeWidgetItemValue a where
withListenerPtrQTreeWidgetItemPtr = HoppyP.flip ($) . toListenerPtrQTreeWidgetItemConst
class (M34.QObjectConstPtr this) => ListenerPtrQTreeWidgetItemConstPtr this where
toListenerPtrQTreeWidgetItemConst :: this -> ListenerPtrQTreeWidgetItemConst
class (ListenerPtrQTreeWidgetItemConstPtr this, M34.QObjectPtr this) => ListenerPtrQTreeWidgetItemPtr this where
toListenerPtrQTreeWidgetItem :: this -> ListenerPtrQTreeWidgetItem
listenerPtrQTreeWidgetItem_connectListener :: (ListenerPtrQTreeWidgetItemPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQTreeWidgetItem_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQTreeWidgetItem arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQTreeWidgetItem_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQTreeWidgetItemConst =
ListenerPtrQTreeWidgetItemConst (HoppyF.Ptr ListenerPtrQTreeWidgetItemConst)
| ListenerPtrQTreeWidgetItemConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItemConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItemConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItemConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemToConst :: ListenerPtrQTreeWidgetItem -> ListenerPtrQTreeWidgetItemConst
castListenerPtrQTreeWidgetItemToConst (ListenerPtrQTreeWidgetItem ptr') = ListenerPtrQTreeWidgetItemConst $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemToConst (ListenerPtrQTreeWidgetItemGc fptr' ptr') = ListenerPtrQTreeWidgetItemConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItemConst where
nullptr = ListenerPtrQTreeWidgetItemConst HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItemConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItemConst ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItemConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItemConst where
delete (ListenerPtrQTreeWidgetItemConst ptr') = delete'ListenerPtrQTreeWidgetItem ptr'
delete (ListenerPtrQTreeWidgetItemConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItemConst", " object."]
toGc this'@(ListenerPtrQTreeWidgetItemConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemConstGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemConstPtr ListenerPtrQTreeWidgetItemConst where
toListenerPtrQTreeWidgetItemConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItemConst where
toQObjectConst (ListenerPtrQTreeWidgetItemConst ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemToQObject ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemToQObject ptr'
data ListenerPtrQTreeWidgetItem =
ListenerPtrQTreeWidgetItem (HoppyF.Ptr ListenerPtrQTreeWidgetItem)
| ListenerPtrQTreeWidgetItemGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItem)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItem where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItem where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemToNonconst :: ListenerPtrQTreeWidgetItemConst -> ListenerPtrQTreeWidgetItem
castListenerPtrQTreeWidgetItemToNonconst (ListenerPtrQTreeWidgetItemConst ptr') = ListenerPtrQTreeWidgetItem $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemToNonconst (ListenerPtrQTreeWidgetItemConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItem where
nullptr = ListenerPtrQTreeWidgetItem HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItem ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItem ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItem _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItem where
delete (ListenerPtrQTreeWidgetItem ptr') = delete'ListenerPtrQTreeWidgetItem $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQTreeWidgetItemConst)
delete (ListenerPtrQTreeWidgetItemGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItem", " object."]
toGc this'@(ListenerPtrQTreeWidgetItem ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemConstPtr ListenerPtrQTreeWidgetItem where
toListenerPtrQTreeWidgetItemConst (ListenerPtrQTreeWidgetItem ptr') = ListenerPtrQTreeWidgetItemConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
toListenerPtrQTreeWidgetItemConst (ListenerPtrQTreeWidgetItemGc fptr' ptr') = ListenerPtrQTreeWidgetItemConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
instance ListenerPtrQTreeWidgetItemPtr ListenerPtrQTreeWidgetItem where
toListenerPtrQTreeWidgetItem = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItem where
toQObjectConst (ListenerPtrQTreeWidgetItem ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
instance M34.QObjectPtr ListenerPtrQTreeWidgetItem where
toQObject (ListenerPtrQTreeWidgetItem ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
toQObject (ListenerPtrQTreeWidgetItemGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemConst) ptr'
listenerPtrQTreeWidgetItem_new :: (M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQTreeWidgetItem
listenerPtrQTreeWidgetItem_new arg'1 =
M182.callbackPtrQTreeWidgetItemVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQTreeWidgetItem
(listenerPtrQTreeWidgetItem_new' arg'1')
listenerPtrQTreeWidgetItem_newWithParent :: (M34.QObjectPtr arg'2) => (M326.QTreeWidgetItem -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQTreeWidgetItem
listenerPtrQTreeWidgetItem_newWithParent arg'1 arg'2 =
M182.callbackPtrQTreeWidgetItemVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQTreeWidgetItem
(listenerPtrQTreeWidgetItem_newWithParent' arg'1' arg'2')
class ListenerPtrQTreeWidgetItemSuper a where
downToListenerPtrQTreeWidgetItem :: a -> ListenerPtrQTreeWidgetItem
instance ListenerPtrQTreeWidgetItemSuper M34.QObject where
downToListenerPtrQTreeWidgetItem = castListenerPtrQTreeWidgetItemToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemConst $ castQObjectToListenerPtrQTreeWidgetItem ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItem ptr'
class ListenerPtrQTreeWidgetItemSuperConst a where
downToListenerPtrQTreeWidgetItemConst :: a -> ListenerPtrQTreeWidgetItemConst
instance ListenerPtrQTreeWidgetItemSuperConst M34.QObjectConst where
downToListenerPtrQTreeWidgetItemConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemConst $ castQObjectToListenerPtrQTreeWidgetItem ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItem ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItem)) ListenerPtrQTreeWidgetItem where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItem)) ListenerPtrQTreeWidgetItem where
decode = HoppyP.fmap ListenerPtrQTreeWidgetItem . HoppyF.peek
class ListenerPtrQTreeWidgetItemIntValue a where
withListenerPtrQTreeWidgetItemIntPtr :: a -> (ListenerPtrQTreeWidgetItemIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQTreeWidgetItemIntConstPtr a => ListenerPtrQTreeWidgetItemIntValue a where
withListenerPtrQTreeWidgetItemIntPtr = HoppyP.flip ($) . toListenerPtrQTreeWidgetItemIntConst
class (M34.QObjectConstPtr this) => ListenerPtrQTreeWidgetItemIntConstPtr this where
toListenerPtrQTreeWidgetItemIntConst :: this -> ListenerPtrQTreeWidgetItemIntConst
class (ListenerPtrQTreeWidgetItemIntConstPtr this, M34.QObjectPtr this) => ListenerPtrQTreeWidgetItemIntPtr this where
toListenerPtrQTreeWidgetItemInt :: this -> ListenerPtrQTreeWidgetItemInt
listenerPtrQTreeWidgetItemInt_connectListener :: (ListenerPtrQTreeWidgetItemIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQTreeWidgetItemInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQTreeWidgetItemInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQTreeWidgetItemInt_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQTreeWidgetItemIntConst =
ListenerPtrQTreeWidgetItemIntConst (HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst)
| ListenerPtrQTreeWidgetItemIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItemIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItemIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemIntToConst :: ListenerPtrQTreeWidgetItemInt -> ListenerPtrQTreeWidgetItemIntConst
castListenerPtrQTreeWidgetItemIntToConst (ListenerPtrQTreeWidgetItemInt ptr') = ListenerPtrQTreeWidgetItemIntConst $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemIntToConst (ListenerPtrQTreeWidgetItemIntGc fptr' ptr') = ListenerPtrQTreeWidgetItemIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItemIntConst where
nullptr = ListenerPtrQTreeWidgetItemIntConst HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItemIntConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItemIntConst ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItemIntConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItemIntConst where
delete (ListenerPtrQTreeWidgetItemIntConst ptr') = delete'ListenerPtrQTreeWidgetItemInt ptr'
delete (ListenerPtrQTreeWidgetItemIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItemIntConst", " object."]
toGc this'@(ListenerPtrQTreeWidgetItemIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItemInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemIntConstGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemIntConstPtr ListenerPtrQTreeWidgetItemIntConst where
toListenerPtrQTreeWidgetItemIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItemIntConst where
toQObjectConst (ListenerPtrQTreeWidgetItemIntConst ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemIntToQObject ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemIntToQObject ptr'
data ListenerPtrQTreeWidgetItemInt =
ListenerPtrQTreeWidgetItemInt (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)
| ListenerPtrQTreeWidgetItemIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItemInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItemInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemIntToNonconst :: ListenerPtrQTreeWidgetItemIntConst -> ListenerPtrQTreeWidgetItemInt
castListenerPtrQTreeWidgetItemIntToNonconst (ListenerPtrQTreeWidgetItemIntConst ptr') = ListenerPtrQTreeWidgetItemInt $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemIntToNonconst (ListenerPtrQTreeWidgetItemIntConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItemInt where
nullptr = ListenerPtrQTreeWidgetItemInt HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItemInt ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItemInt ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemIntGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItemInt _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItemInt where
delete (ListenerPtrQTreeWidgetItemInt ptr') = delete'ListenerPtrQTreeWidgetItemInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst)
delete (ListenerPtrQTreeWidgetItemIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItemInt", " object."]
toGc this'@(ListenerPtrQTreeWidgetItemInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItemInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemIntGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemIntConstPtr ListenerPtrQTreeWidgetItemInt where
toListenerPtrQTreeWidgetItemIntConst (ListenerPtrQTreeWidgetItemInt ptr') = ListenerPtrQTreeWidgetItemIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
toListenerPtrQTreeWidgetItemIntConst (ListenerPtrQTreeWidgetItemIntGc fptr' ptr') = ListenerPtrQTreeWidgetItemIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
instance ListenerPtrQTreeWidgetItemIntPtr ListenerPtrQTreeWidgetItemInt where
toListenerPtrQTreeWidgetItemInt = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItemInt where
toQObjectConst (ListenerPtrQTreeWidgetItemInt ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
instance M34.QObjectPtr ListenerPtrQTreeWidgetItemInt where
toQObject (ListenerPtrQTreeWidgetItemInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
toQObject (ListenerPtrQTreeWidgetItemIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemInt -> HoppyF.Ptr ListenerPtrQTreeWidgetItemIntConst) ptr'
listenerPtrQTreeWidgetItemInt_new :: (M326.QTreeWidgetItem -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQTreeWidgetItemInt
listenerPtrQTreeWidgetItemInt_new arg'1 =
M182.callbackPtrQTreeWidgetItemIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQTreeWidgetItemInt
(listenerPtrQTreeWidgetItemInt_new' arg'1')
listenerPtrQTreeWidgetItemInt_newWithParent :: (M34.QObjectPtr arg'2) => (M326.QTreeWidgetItem -> HoppyP.Int -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQTreeWidgetItemInt
listenerPtrQTreeWidgetItemInt_newWithParent arg'1 arg'2 =
M182.callbackPtrQTreeWidgetItemIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQTreeWidgetItemInt
(listenerPtrQTreeWidgetItemInt_newWithParent' arg'1' arg'2')
class ListenerPtrQTreeWidgetItemIntSuper a where
downToListenerPtrQTreeWidgetItemInt :: a -> ListenerPtrQTreeWidgetItemInt
instance ListenerPtrQTreeWidgetItemIntSuper M34.QObject where
downToListenerPtrQTreeWidgetItemInt = castListenerPtrQTreeWidgetItemIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemIntConst $ castQObjectToListenerPtrQTreeWidgetItemInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemIntConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItemInt ptr'
class ListenerPtrQTreeWidgetItemIntSuperConst a where
downToListenerPtrQTreeWidgetItemIntConst :: a -> ListenerPtrQTreeWidgetItemIntConst
instance ListenerPtrQTreeWidgetItemIntSuperConst M34.QObjectConst where
downToListenerPtrQTreeWidgetItemIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemIntConst $ castQObjectToListenerPtrQTreeWidgetItemInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemIntConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItemInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)) ListenerPtrQTreeWidgetItemInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItemInt)) ListenerPtrQTreeWidgetItemInt where
decode = HoppyP.fmap ListenerPtrQTreeWidgetItemInt . HoppyF.peek
class ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemValue a where
withListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr :: a -> (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr a => ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemValue a where
withListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr = HoppyP.flip ($) . toListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst
class (M34.QObjectConstPtr this) => ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr this where
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst :: this -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst
class (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr this, M34.QObjectPtr this) => ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr this where
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: this -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener :: (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQTreeWidgetItemPtrQTreeWidgetItem arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst =
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst)
| ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToConst :: ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
nullptr = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
delete (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') = delete'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr'
delete (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst", " object."]
toGc this'@(ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst where
toQObjectConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject ptr'
data ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem =
ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)
| ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToNonconst :: ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToNonconst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem $ HoppyF.castPtr ptr'
castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToNonconst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
nullptr = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem HoppyF.nullPtr
withCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') f' = f' ptr'
withCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = ptr'
toPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem _) = HoppyP.return ()
touchCppPtr (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
delete (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = delete'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst)
delete (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem", " object."]
toGc this'@(ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc {}) = HoppyP.return this'
instance ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
instance ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
toListenerPtrQTreeWidgetItemPtrQTreeWidgetItem = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
toQObjectConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = M34.QObjectConst $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
toQObjectConst (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
instance M34.QObjectPtr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
toQObject (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
toQObject (ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem -> HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst) ptr'
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new :: (M326.QTreeWidgetItem -> M326.QTreeWidgetItem -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new arg'1 =
M182.callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
(listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_new' arg'1')
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent :: (M34.QObjectPtr arg'2) => (M326.QTreeWidgetItem -> M326.QTreeWidgetItem -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent arg'1 arg'2 =
M182.callbackPtrQTreeWidgetItemPtrQTreeWidgetItemVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
(listenerPtrQTreeWidgetItemPtrQTreeWidgetItem_newWithParent' arg'1' arg'2')
class ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuper a where
downToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem :: a -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem
instance ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuper M34.QObject where
downToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem = castListenerPtrQTreeWidgetItemPtrQTreeWidgetItemToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst $ castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr'
class ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuperConst a where
downToListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst :: a -> ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst
instance ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemSuperConst M34.QObjectConst where
downToListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConst $ castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQTreeWidgetItemPtrQTreeWidgetItemConstGc fptr' $ castQObjectToListenerPtrQTreeWidgetItemPtrQTreeWidgetItem ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)) ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem)) ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem where
decode = HoppyP.fmap ListenerPtrQTreeWidgetItemPtrQTreeWidgetItem . HoppyF.peek
class ListenerPtrQWidgetPtrQWidgetValue a where
withListenerPtrQWidgetPtrQWidgetPtr :: a -> (ListenerPtrQWidgetPtrQWidgetConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerPtrQWidgetPtrQWidgetConstPtr a => ListenerPtrQWidgetPtrQWidgetValue a where
withListenerPtrQWidgetPtrQWidgetPtr = HoppyP.flip ($) . toListenerPtrQWidgetPtrQWidgetConst
class (M34.QObjectConstPtr this) => ListenerPtrQWidgetPtrQWidgetConstPtr this where
toListenerPtrQWidgetPtrQWidgetConst :: this -> ListenerPtrQWidgetPtrQWidgetConst
class (ListenerPtrQWidgetPtrQWidgetConstPtr this, M34.QObjectPtr this) => ListenerPtrQWidgetPtrQWidgetPtr this where
toListenerPtrQWidgetPtrQWidget :: this -> ListenerPtrQWidgetPtrQWidget
listenerPtrQWidgetPtrQWidget_connectListener :: (ListenerPtrQWidgetPtrQWidgetPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerPtrQWidgetPtrQWidget_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerPtrQWidgetPtrQWidget arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerPtrQWidgetPtrQWidget_connectListener' arg'1' arg'2' arg'3')
data ListenerPtrQWidgetPtrQWidgetConst =
ListenerPtrQWidgetPtrQWidgetConst (HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst)
| ListenerPtrQWidgetPtrQWidgetConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQWidgetPtrQWidgetConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQWidgetPtrQWidgetConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQWidgetPtrQWidgetToConst :: ListenerPtrQWidgetPtrQWidget -> ListenerPtrQWidgetPtrQWidgetConst
castListenerPtrQWidgetPtrQWidgetToConst (ListenerPtrQWidgetPtrQWidget ptr') = ListenerPtrQWidgetPtrQWidgetConst $ HoppyF.castPtr ptr'
castListenerPtrQWidgetPtrQWidgetToConst (ListenerPtrQWidgetPtrQWidgetGc fptr' ptr') = ListenerPtrQWidgetPtrQWidgetConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQWidgetPtrQWidgetConst where
nullptr = ListenerPtrQWidgetPtrQWidgetConst HoppyF.nullPtr
withCppPtr (ListenerPtrQWidgetPtrQWidgetConst ptr') f' = f' ptr'
withCppPtr (ListenerPtrQWidgetPtrQWidgetConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQWidgetPtrQWidgetConst ptr') = ptr'
toPtr (ListenerPtrQWidgetPtrQWidgetConstGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQWidgetPtrQWidgetConst _) = HoppyP.return ()
touchCppPtr (ListenerPtrQWidgetPtrQWidgetConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQWidgetPtrQWidgetConst where
delete (ListenerPtrQWidgetPtrQWidgetConst ptr') = delete'ListenerPtrQWidgetPtrQWidget ptr'
delete (ListenerPtrQWidgetPtrQWidgetConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQWidgetPtrQWidgetConst", " object."]
toGc this'@(ListenerPtrQWidgetPtrQWidgetConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQWidgetPtrQWidgetConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQWidgetPtrQWidget :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQWidgetPtrQWidgetConstGc {}) = HoppyP.return this'
instance ListenerPtrQWidgetPtrQWidgetConstPtr ListenerPtrQWidgetPtrQWidgetConst where
toListenerPtrQWidgetPtrQWidgetConst = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQWidgetPtrQWidgetConst where
toQObjectConst (ListenerPtrQWidgetPtrQWidgetConst ptr') = M34.QObjectConst $ castListenerPtrQWidgetPtrQWidgetToQObject ptr'
toQObjectConst (ListenerPtrQWidgetPtrQWidgetConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQWidgetPtrQWidgetToQObject ptr'
data ListenerPtrQWidgetPtrQWidget =
ListenerPtrQWidgetPtrQWidget (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)
| ListenerPtrQWidgetPtrQWidgetGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerPtrQWidgetPtrQWidget where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerPtrQWidgetPtrQWidget where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerPtrQWidgetPtrQWidgetToNonconst :: ListenerPtrQWidgetPtrQWidgetConst -> ListenerPtrQWidgetPtrQWidget
castListenerPtrQWidgetPtrQWidgetToNonconst (ListenerPtrQWidgetPtrQWidgetConst ptr') = ListenerPtrQWidgetPtrQWidget $ HoppyF.castPtr ptr'
castListenerPtrQWidgetPtrQWidgetToNonconst (ListenerPtrQWidgetPtrQWidgetConstGc fptr' ptr') = ListenerPtrQWidgetPtrQWidgetGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerPtrQWidgetPtrQWidget where
nullptr = ListenerPtrQWidgetPtrQWidget HoppyF.nullPtr
withCppPtr (ListenerPtrQWidgetPtrQWidget ptr') f' = f' ptr'
withCppPtr (ListenerPtrQWidgetPtrQWidgetGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerPtrQWidgetPtrQWidget ptr') = ptr'
toPtr (ListenerPtrQWidgetPtrQWidgetGc _ ptr') = ptr'
touchCppPtr (ListenerPtrQWidgetPtrQWidget _) = HoppyP.return ()
touchCppPtr (ListenerPtrQWidgetPtrQWidgetGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerPtrQWidgetPtrQWidget where
delete (ListenerPtrQWidgetPtrQWidget ptr') = delete'ListenerPtrQWidgetPtrQWidget $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst)
delete (ListenerPtrQWidgetPtrQWidgetGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerPtrQWidgetPtrQWidget", " object."]
toGc this'@(ListenerPtrQWidgetPtrQWidget ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerPtrQWidgetPtrQWidgetGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerPtrQWidgetPtrQWidget :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerPtrQWidgetPtrQWidgetGc {}) = HoppyP.return this'
instance ListenerPtrQWidgetPtrQWidgetConstPtr ListenerPtrQWidgetPtrQWidget where
toListenerPtrQWidgetPtrQWidgetConst (ListenerPtrQWidgetPtrQWidget ptr') = ListenerPtrQWidgetPtrQWidgetConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
toListenerPtrQWidgetPtrQWidgetConst (ListenerPtrQWidgetPtrQWidgetGc fptr' ptr') = ListenerPtrQWidgetPtrQWidgetConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
instance ListenerPtrQWidgetPtrQWidgetPtr ListenerPtrQWidgetPtrQWidget where
toListenerPtrQWidgetPtrQWidget = HoppyP.id
instance M34.QObjectConstPtr ListenerPtrQWidgetPtrQWidget where
toQObjectConst (ListenerPtrQWidgetPtrQWidget ptr') = M34.QObjectConst $ castListenerPtrQWidgetPtrQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
toQObjectConst (ListenerPtrQWidgetPtrQWidgetGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerPtrQWidgetPtrQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
instance M34.QObjectPtr ListenerPtrQWidgetPtrQWidget where
toQObject (ListenerPtrQWidgetPtrQWidget ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQWidgetPtrQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
toQObject (ListenerPtrQWidgetPtrQWidgetGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerPtrQWidgetPtrQWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerPtrQWidgetPtrQWidget -> HoppyF.Ptr ListenerPtrQWidgetPtrQWidgetConst) ptr'
listenerPtrQWidgetPtrQWidget_new :: (M330.QWidget -> M330.QWidget -> HoppyP.IO ()) -> HoppyP.IO ListenerPtrQWidgetPtrQWidget
listenerPtrQWidgetPtrQWidget_new arg'1 =
M182.callbackPtrQWidgetPtrQWidgetVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerPtrQWidgetPtrQWidget
(listenerPtrQWidgetPtrQWidget_new' arg'1')
listenerPtrQWidgetPtrQWidget_newWithParent :: (M34.QObjectPtr arg'2) => (M330.QWidget -> M330.QWidget -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerPtrQWidgetPtrQWidget
listenerPtrQWidgetPtrQWidget_newWithParent arg'1 arg'2 =
M182.callbackPtrQWidgetPtrQWidgetVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerPtrQWidgetPtrQWidget
(listenerPtrQWidgetPtrQWidget_newWithParent' arg'1' arg'2')
class ListenerPtrQWidgetPtrQWidgetSuper a where
downToListenerPtrQWidgetPtrQWidget :: a -> ListenerPtrQWidgetPtrQWidget
instance ListenerPtrQWidgetPtrQWidgetSuper M34.QObject where
downToListenerPtrQWidgetPtrQWidget = castListenerPtrQWidgetPtrQWidgetToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerPtrQWidgetPtrQWidgetConst $ castQObjectToListenerPtrQWidgetPtrQWidget ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQWidgetPtrQWidgetConstGc fptr' $ castQObjectToListenerPtrQWidgetPtrQWidget ptr'
class ListenerPtrQWidgetPtrQWidgetSuperConst a where
downToListenerPtrQWidgetPtrQWidgetConst :: a -> ListenerPtrQWidgetPtrQWidgetConst
instance ListenerPtrQWidgetPtrQWidgetSuperConst M34.QObjectConst where
downToListenerPtrQWidgetPtrQWidgetConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerPtrQWidgetPtrQWidgetConst $ castQObjectToListenerPtrQWidgetPtrQWidget ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerPtrQWidgetPtrQWidgetConstGc fptr' $ castQObjectToListenerPtrQWidgetPtrQWidget ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)) ListenerPtrQWidgetPtrQWidget where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerPtrQWidgetPtrQWidget)) ListenerPtrQWidgetPtrQWidget where
decode = HoppyP.fmap ListenerPtrQWidgetPtrQWidget . HoppyF.peek
class ListenerQAbstractSliderActionValue a where
withListenerQAbstractSliderActionPtr :: a -> (ListenerQAbstractSliderActionConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQAbstractSliderActionConstPtr a => ListenerQAbstractSliderActionValue a where
withListenerQAbstractSliderActionPtr = HoppyP.flip ($) . toListenerQAbstractSliderActionConst
class (M34.QObjectConstPtr this) => ListenerQAbstractSliderActionConstPtr this where
toListenerQAbstractSliderActionConst :: this -> ListenerQAbstractSliderActionConst
class (ListenerQAbstractSliderActionConstPtr this, M34.QObjectPtr this) => ListenerQAbstractSliderActionPtr this where
toListenerQAbstractSliderAction :: this -> ListenerQAbstractSliderAction
listenerQAbstractSliderAction_connectListener :: (ListenerQAbstractSliderActionPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQAbstractSliderAction_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQAbstractSliderAction arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQAbstractSliderAction_connectListener' arg'1' arg'2' arg'3')
data ListenerQAbstractSliderActionConst =
ListenerQAbstractSliderActionConst (HoppyF.Ptr ListenerQAbstractSliderActionConst)
| ListenerQAbstractSliderActionConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQAbstractSliderActionConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQAbstractSliderActionConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQAbstractSliderActionConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQAbstractSliderActionToConst :: ListenerQAbstractSliderAction -> ListenerQAbstractSliderActionConst
castListenerQAbstractSliderActionToConst (ListenerQAbstractSliderAction ptr') = ListenerQAbstractSliderActionConst $ HoppyF.castPtr ptr'
castListenerQAbstractSliderActionToConst (ListenerQAbstractSliderActionGc fptr' ptr') = ListenerQAbstractSliderActionConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQAbstractSliderActionConst where
nullptr = ListenerQAbstractSliderActionConst HoppyF.nullPtr
withCppPtr (ListenerQAbstractSliderActionConst ptr') f' = f' ptr'
withCppPtr (ListenerQAbstractSliderActionConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQAbstractSliderActionConst ptr') = ptr'
toPtr (ListenerQAbstractSliderActionConstGc _ ptr') = ptr'
touchCppPtr (ListenerQAbstractSliderActionConst _) = HoppyP.return ()
touchCppPtr (ListenerQAbstractSliderActionConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQAbstractSliderActionConst where
delete (ListenerQAbstractSliderActionConst ptr') = delete'ListenerQAbstractSliderAction ptr'
delete (ListenerQAbstractSliderActionConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQAbstractSliderActionConst", " object."]
toGc this'@(ListenerQAbstractSliderActionConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQAbstractSliderActionConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQAbstractSliderAction :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQAbstractSliderActionConstGc {}) = HoppyP.return this'
instance ListenerQAbstractSliderActionConstPtr ListenerQAbstractSliderActionConst where
toListenerQAbstractSliderActionConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQAbstractSliderActionConst where
toQObjectConst (ListenerQAbstractSliderActionConst ptr') = M34.QObjectConst $ castListenerQAbstractSliderActionToQObject ptr'
toQObjectConst (ListenerQAbstractSliderActionConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQAbstractSliderActionToQObject ptr'
data ListenerQAbstractSliderAction =
ListenerQAbstractSliderAction (HoppyF.Ptr ListenerQAbstractSliderAction)
| ListenerQAbstractSliderActionGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQAbstractSliderAction)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQAbstractSliderAction where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQAbstractSliderAction where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQAbstractSliderActionToNonconst :: ListenerQAbstractSliderActionConst -> ListenerQAbstractSliderAction
castListenerQAbstractSliderActionToNonconst (ListenerQAbstractSliderActionConst ptr') = ListenerQAbstractSliderAction $ HoppyF.castPtr ptr'
castListenerQAbstractSliderActionToNonconst (ListenerQAbstractSliderActionConstGc fptr' ptr') = ListenerQAbstractSliderActionGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQAbstractSliderAction where
nullptr = ListenerQAbstractSliderAction HoppyF.nullPtr
withCppPtr (ListenerQAbstractSliderAction ptr') f' = f' ptr'
withCppPtr (ListenerQAbstractSliderActionGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQAbstractSliderAction ptr') = ptr'
toPtr (ListenerQAbstractSliderActionGc _ ptr') = ptr'
touchCppPtr (ListenerQAbstractSliderAction _) = HoppyP.return ()
touchCppPtr (ListenerQAbstractSliderActionGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQAbstractSliderAction where
delete (ListenerQAbstractSliderAction ptr') = delete'ListenerQAbstractSliderAction $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQAbstractSliderActionConst)
delete (ListenerQAbstractSliderActionGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQAbstractSliderAction", " object."]
toGc this'@(ListenerQAbstractSliderAction ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQAbstractSliderActionGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQAbstractSliderAction :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQAbstractSliderActionGc {}) = HoppyP.return this'
instance ListenerQAbstractSliderActionConstPtr ListenerQAbstractSliderAction where
toListenerQAbstractSliderActionConst (ListenerQAbstractSliderAction ptr') = ListenerQAbstractSliderActionConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
toListenerQAbstractSliderActionConst (ListenerQAbstractSliderActionGc fptr' ptr') = ListenerQAbstractSliderActionConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
instance ListenerQAbstractSliderActionPtr ListenerQAbstractSliderAction where
toListenerQAbstractSliderAction = HoppyP.id
instance M34.QObjectConstPtr ListenerQAbstractSliderAction where
toQObjectConst (ListenerQAbstractSliderAction ptr') = M34.QObjectConst $ castListenerQAbstractSliderActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
toQObjectConst (ListenerQAbstractSliderActionGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQAbstractSliderActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
instance M34.QObjectPtr ListenerQAbstractSliderAction where
toQObject (ListenerQAbstractSliderAction ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQAbstractSliderActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
toQObject (ListenerQAbstractSliderActionGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQAbstractSliderActionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQAbstractSliderAction -> HoppyF.Ptr ListenerQAbstractSliderActionConst) ptr'
listenerQAbstractSliderAction_new :: (M198.QAbstractSliderAction -> HoppyP.IO ()) -> HoppyP.IO ListenerQAbstractSliderAction
listenerQAbstractSliderAction_new arg'1 =
M182.callbackQAbstractSliderActionVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQAbstractSliderAction
(listenerQAbstractSliderAction_new' arg'1')
listenerQAbstractSliderAction_newWithParent :: (M34.QObjectPtr arg'2) => (M198.QAbstractSliderAction -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQAbstractSliderAction
listenerQAbstractSliderAction_newWithParent arg'1 arg'2 =
M182.callbackQAbstractSliderActionVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQAbstractSliderAction
(listenerQAbstractSliderAction_newWithParent' arg'1' arg'2')
class ListenerQAbstractSliderActionSuper a where
downToListenerQAbstractSliderAction :: a -> ListenerQAbstractSliderAction
instance ListenerQAbstractSliderActionSuper M34.QObject where
downToListenerQAbstractSliderAction = castListenerQAbstractSliderActionToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQAbstractSliderActionConst $ castQObjectToListenerQAbstractSliderAction ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQAbstractSliderActionConstGc fptr' $ castQObjectToListenerQAbstractSliderAction ptr'
class ListenerQAbstractSliderActionSuperConst a where
downToListenerQAbstractSliderActionConst :: a -> ListenerQAbstractSliderActionConst
instance ListenerQAbstractSliderActionSuperConst M34.QObjectConst where
downToListenerQAbstractSliderActionConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQAbstractSliderActionConst $ castQObjectToListenerQAbstractSliderAction ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQAbstractSliderActionConstGc fptr' $ castQObjectToListenerQAbstractSliderAction ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQAbstractSliderAction)) ListenerQAbstractSliderAction where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQAbstractSliderAction)) ListenerQAbstractSliderAction where
decode = HoppyP.fmap ListenerQAbstractSliderAction . HoppyF.peek
class ListenerQClipboardModeValue a where
withListenerQClipboardModePtr :: a -> (ListenerQClipboardModeConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQClipboardModeConstPtr a => ListenerQClipboardModeValue a where
withListenerQClipboardModePtr = HoppyP.flip ($) . toListenerQClipboardModeConst
class (M34.QObjectConstPtr this) => ListenerQClipboardModeConstPtr this where
toListenerQClipboardModeConst :: this -> ListenerQClipboardModeConst
class (ListenerQClipboardModeConstPtr this, M34.QObjectPtr this) => ListenerQClipboardModePtr this where
toListenerQClipboardMode :: this -> ListenerQClipboardMode
listenerQClipboardMode_connectListener :: (ListenerQClipboardModePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQClipboardMode_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQClipboardMode arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQClipboardMode_connectListener' arg'1' arg'2' arg'3')
data ListenerQClipboardModeConst =
ListenerQClipboardModeConst (HoppyF.Ptr ListenerQClipboardModeConst)
| ListenerQClipboardModeConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQClipboardModeConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQClipboardModeConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQClipboardModeConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQClipboardModeToConst :: ListenerQClipboardMode -> ListenerQClipboardModeConst
castListenerQClipboardModeToConst (ListenerQClipboardMode ptr') = ListenerQClipboardModeConst $ HoppyF.castPtr ptr'
castListenerQClipboardModeToConst (ListenerQClipboardModeGc fptr' ptr') = ListenerQClipboardModeConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQClipboardModeConst where
nullptr = ListenerQClipboardModeConst HoppyF.nullPtr
withCppPtr (ListenerQClipboardModeConst ptr') f' = f' ptr'
withCppPtr (ListenerQClipboardModeConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQClipboardModeConst ptr') = ptr'
toPtr (ListenerQClipboardModeConstGc _ ptr') = ptr'
touchCppPtr (ListenerQClipboardModeConst _) = HoppyP.return ()
touchCppPtr (ListenerQClipboardModeConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQClipboardModeConst where
delete (ListenerQClipboardModeConst ptr') = delete'ListenerQClipboardMode ptr'
delete (ListenerQClipboardModeConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQClipboardModeConst", " object."]
toGc this'@(ListenerQClipboardModeConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQClipboardModeConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQClipboardMode :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQClipboardModeConstGc {}) = HoppyP.return this'
instance ListenerQClipboardModeConstPtr ListenerQClipboardModeConst where
toListenerQClipboardModeConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQClipboardModeConst where
toQObjectConst (ListenerQClipboardModeConst ptr') = M34.QObjectConst $ castListenerQClipboardModeToQObject ptr'
toQObjectConst (ListenerQClipboardModeConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQClipboardModeToQObject ptr'
data ListenerQClipboardMode =
ListenerQClipboardMode (HoppyF.Ptr ListenerQClipboardMode)
| ListenerQClipboardModeGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQClipboardMode)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQClipboardMode where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQClipboardMode where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQClipboardModeToNonconst :: ListenerQClipboardModeConst -> ListenerQClipboardMode
castListenerQClipboardModeToNonconst (ListenerQClipboardModeConst ptr') = ListenerQClipboardMode $ HoppyF.castPtr ptr'
castListenerQClipboardModeToNonconst (ListenerQClipboardModeConstGc fptr' ptr') = ListenerQClipboardModeGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQClipboardMode where
nullptr = ListenerQClipboardMode HoppyF.nullPtr
withCppPtr (ListenerQClipboardMode ptr') f' = f' ptr'
withCppPtr (ListenerQClipboardModeGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQClipboardMode ptr') = ptr'
toPtr (ListenerQClipboardModeGc _ ptr') = ptr'
touchCppPtr (ListenerQClipboardMode _) = HoppyP.return ()
touchCppPtr (ListenerQClipboardModeGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQClipboardMode where
delete (ListenerQClipboardMode ptr') = delete'ListenerQClipboardMode $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQClipboardModeConst)
delete (ListenerQClipboardModeGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQClipboardMode", " object."]
toGc this'@(ListenerQClipboardMode ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQClipboardModeGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQClipboardMode :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQClipboardModeGc {}) = HoppyP.return this'
instance ListenerQClipboardModeConstPtr ListenerQClipboardMode where
toListenerQClipboardModeConst (ListenerQClipboardMode ptr') = ListenerQClipboardModeConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
toListenerQClipboardModeConst (ListenerQClipboardModeGc fptr' ptr') = ListenerQClipboardModeConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
instance ListenerQClipboardModePtr ListenerQClipboardMode where
toListenerQClipboardMode = HoppyP.id
instance M34.QObjectConstPtr ListenerQClipboardMode where
toQObjectConst (ListenerQClipboardMode ptr') = M34.QObjectConst $ castListenerQClipboardModeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
toQObjectConst (ListenerQClipboardModeGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQClipboardModeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
instance M34.QObjectPtr ListenerQClipboardMode where
toQObject (ListenerQClipboardMode ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQClipboardModeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
toQObject (ListenerQClipboardModeGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQClipboardModeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQClipboardMode -> HoppyF.Ptr ListenerQClipboardModeConst) ptr'
listenerQClipboardMode_new :: (M102.QClipboardMode -> HoppyP.IO ()) -> HoppyP.IO ListenerQClipboardMode
listenerQClipboardMode_new arg'1 =
M182.callbackQClipboardModeVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQClipboardMode
(listenerQClipboardMode_new' arg'1')
listenerQClipboardMode_newWithParent :: (M34.QObjectPtr arg'2) => (M102.QClipboardMode -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQClipboardMode
listenerQClipboardMode_newWithParent arg'1 arg'2 =
M182.callbackQClipboardModeVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQClipboardMode
(listenerQClipboardMode_newWithParent' arg'1' arg'2')
class ListenerQClipboardModeSuper a where
downToListenerQClipboardMode :: a -> ListenerQClipboardMode
instance ListenerQClipboardModeSuper M34.QObject where
downToListenerQClipboardMode = castListenerQClipboardModeToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQClipboardModeConst $ castQObjectToListenerQClipboardMode ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQClipboardModeConstGc fptr' $ castQObjectToListenerQClipboardMode ptr'
class ListenerQClipboardModeSuperConst a where
downToListenerQClipboardModeConst :: a -> ListenerQClipboardModeConst
instance ListenerQClipboardModeSuperConst M34.QObjectConst where
downToListenerQClipboardModeConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQClipboardModeConst $ castQObjectToListenerQClipboardMode ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQClipboardModeConstGc fptr' $ castQObjectToListenerQClipboardMode ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQClipboardMode)) ListenerQClipboardMode where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQClipboardMode)) ListenerQClipboardMode where
decode = HoppyP.fmap ListenerQClipboardMode . HoppyF.peek
class ListenerQDateValue a where
withListenerQDatePtr :: a -> (ListenerQDateConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQDateConstPtr a => ListenerQDateValue a where
withListenerQDatePtr = HoppyP.flip ($) . toListenerQDateConst
class (M34.QObjectConstPtr this) => ListenerQDateConstPtr this where
toListenerQDateConst :: this -> ListenerQDateConst
class (ListenerQDateConstPtr this, M34.QObjectPtr this) => ListenerQDatePtr this where
toListenerQDate :: this -> ListenerQDate
listenerQDate_connectListener :: (ListenerQDatePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQDate_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQDate arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQDate_connectListener' arg'1' arg'2' arg'3')
data ListenerQDateConst =
ListenerQDateConst (HoppyF.Ptr ListenerQDateConst)
| ListenerQDateConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQDateConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQDateConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQDateConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQDateToConst :: ListenerQDate -> ListenerQDateConst
castListenerQDateToConst (ListenerQDate ptr') = ListenerQDateConst $ HoppyF.castPtr ptr'
castListenerQDateToConst (ListenerQDateGc fptr' ptr') = ListenerQDateConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQDateConst where
nullptr = ListenerQDateConst HoppyF.nullPtr
withCppPtr (ListenerQDateConst ptr') f' = f' ptr'
withCppPtr (ListenerQDateConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQDateConst ptr') = ptr'
toPtr (ListenerQDateConstGc _ ptr') = ptr'
touchCppPtr (ListenerQDateConst _) = HoppyP.return ()
touchCppPtr (ListenerQDateConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQDateConst where
delete (ListenerQDateConst ptr') = delete'ListenerQDate ptr'
delete (ListenerQDateConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQDateConst", " object."]
toGc this'@(ListenerQDateConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQDateConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQDate :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQDateConstGc {}) = HoppyP.return this'
instance ListenerQDateConstPtr ListenerQDateConst where
toListenerQDateConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQDateConst where
toQObjectConst (ListenerQDateConst ptr') = M34.QObjectConst $ castListenerQDateToQObject ptr'
toQObjectConst (ListenerQDateConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQDateToQObject ptr'
data ListenerQDate =
ListenerQDate (HoppyF.Ptr ListenerQDate)
| ListenerQDateGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQDate)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQDate where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQDate where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQDateToNonconst :: ListenerQDateConst -> ListenerQDate
castListenerQDateToNonconst (ListenerQDateConst ptr') = ListenerQDate $ HoppyF.castPtr ptr'
castListenerQDateToNonconst (ListenerQDateConstGc fptr' ptr') = ListenerQDateGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQDate where
nullptr = ListenerQDate HoppyF.nullPtr
withCppPtr (ListenerQDate ptr') f' = f' ptr'
withCppPtr (ListenerQDateGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQDate ptr') = ptr'
toPtr (ListenerQDateGc _ ptr') = ptr'
touchCppPtr (ListenerQDate _) = HoppyP.return ()
touchCppPtr (ListenerQDateGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQDate where
delete (ListenerQDate ptr') = delete'ListenerQDate $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQDateConst)
delete (ListenerQDateGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQDate", " object."]
toGc this'@(ListenerQDate ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQDateGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQDate :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQDateGc {}) = HoppyP.return this'
instance ListenerQDateConstPtr ListenerQDate where
toListenerQDateConst (ListenerQDate ptr') = ListenerQDateConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
toListenerQDateConst (ListenerQDateGc fptr' ptr') = ListenerQDateConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
instance ListenerQDatePtr ListenerQDate where
toListenerQDate = HoppyP.id
instance M34.QObjectConstPtr ListenerQDate where
toQObjectConst (ListenerQDate ptr') = M34.QObjectConst $ castListenerQDateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
toQObjectConst (ListenerQDateGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQDateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
instance M34.QObjectPtr ListenerQDate where
toQObject (ListenerQDate ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQDateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
toQObject (ListenerQDateGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQDateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDate -> HoppyF.Ptr ListenerQDateConst) ptr'
listenerQDate_new :: (M16.QDate -> HoppyP.IO ()) -> HoppyP.IO ListenerQDate
listenerQDate_new arg'1 =
M182.callbackQDateVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQDate
(listenerQDate_new' arg'1')
listenerQDate_newWithParent :: (M34.QObjectPtr arg'2) => (M16.QDate -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQDate
listenerQDate_newWithParent arg'1 arg'2 =
M182.callbackQDateVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQDate
(listenerQDate_newWithParent' arg'1' arg'2')
class ListenerQDateSuper a where
downToListenerQDate :: a -> ListenerQDate
instance ListenerQDateSuper M34.QObject where
downToListenerQDate = castListenerQDateToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQDateConst $ castQObjectToListenerQDate ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQDateConstGc fptr' $ castQObjectToListenerQDate ptr'
class ListenerQDateSuperConst a where
downToListenerQDateConst :: a -> ListenerQDateConst
instance ListenerQDateSuperConst M34.QObjectConst where
downToListenerQDateConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQDateConst $ castQObjectToListenerQDate ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQDateConstGc fptr' $ castQObjectToListenerQDate ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQDate)) ListenerQDate where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQDate)) ListenerQDate where
decode = HoppyP.fmap ListenerQDate . HoppyF.peek
class ListenerQDockWidgetFeaturesValue a where
withListenerQDockWidgetFeaturesPtr :: a -> (ListenerQDockWidgetFeaturesConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQDockWidgetFeaturesConstPtr a => ListenerQDockWidgetFeaturesValue a where
withListenerQDockWidgetFeaturesPtr = HoppyP.flip ($) . toListenerQDockWidgetFeaturesConst
class (M34.QObjectConstPtr this) => ListenerQDockWidgetFeaturesConstPtr this where
toListenerQDockWidgetFeaturesConst :: this -> ListenerQDockWidgetFeaturesConst
class (ListenerQDockWidgetFeaturesConstPtr this, M34.QObjectPtr this) => ListenerQDockWidgetFeaturesPtr this where
toListenerQDockWidgetFeatures :: this -> ListenerQDockWidgetFeatures
listenerQDockWidgetFeatures_connectListener :: (ListenerQDockWidgetFeaturesPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQDockWidgetFeatures_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQDockWidgetFeatures arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQDockWidgetFeatures_connectListener' arg'1' arg'2' arg'3')
data ListenerQDockWidgetFeaturesConst =
ListenerQDockWidgetFeaturesConst (HoppyF.Ptr ListenerQDockWidgetFeaturesConst)
| ListenerQDockWidgetFeaturesConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQDockWidgetFeaturesConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQDockWidgetFeaturesConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQDockWidgetFeaturesConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQDockWidgetFeaturesToConst :: ListenerQDockWidgetFeatures -> ListenerQDockWidgetFeaturesConst
castListenerQDockWidgetFeaturesToConst (ListenerQDockWidgetFeatures ptr') = ListenerQDockWidgetFeaturesConst $ HoppyF.castPtr ptr'
castListenerQDockWidgetFeaturesToConst (ListenerQDockWidgetFeaturesGc fptr' ptr') = ListenerQDockWidgetFeaturesConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQDockWidgetFeaturesConst where
nullptr = ListenerQDockWidgetFeaturesConst HoppyF.nullPtr
withCppPtr (ListenerQDockWidgetFeaturesConst ptr') f' = f' ptr'
withCppPtr (ListenerQDockWidgetFeaturesConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQDockWidgetFeaturesConst ptr') = ptr'
toPtr (ListenerQDockWidgetFeaturesConstGc _ ptr') = ptr'
touchCppPtr (ListenerQDockWidgetFeaturesConst _) = HoppyP.return ()
touchCppPtr (ListenerQDockWidgetFeaturesConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQDockWidgetFeaturesConst where
delete (ListenerQDockWidgetFeaturesConst ptr') = delete'ListenerQDockWidgetFeatures ptr'
delete (ListenerQDockWidgetFeaturesConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQDockWidgetFeaturesConst", " object."]
toGc this'@(ListenerQDockWidgetFeaturesConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQDockWidgetFeaturesConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQDockWidgetFeatures :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQDockWidgetFeaturesConstGc {}) = HoppyP.return this'
instance ListenerQDockWidgetFeaturesConstPtr ListenerQDockWidgetFeaturesConst where
toListenerQDockWidgetFeaturesConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQDockWidgetFeaturesConst where
toQObjectConst (ListenerQDockWidgetFeaturesConst ptr') = M34.QObjectConst $ castListenerQDockWidgetFeaturesToQObject ptr'
toQObjectConst (ListenerQDockWidgetFeaturesConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQDockWidgetFeaturesToQObject ptr'
data ListenerQDockWidgetFeatures =
ListenerQDockWidgetFeatures (HoppyF.Ptr ListenerQDockWidgetFeatures)
| ListenerQDockWidgetFeaturesGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQDockWidgetFeatures)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQDockWidgetFeatures where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQDockWidgetFeatures where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQDockWidgetFeaturesToNonconst :: ListenerQDockWidgetFeaturesConst -> ListenerQDockWidgetFeatures
castListenerQDockWidgetFeaturesToNonconst (ListenerQDockWidgetFeaturesConst ptr') = ListenerQDockWidgetFeatures $ HoppyF.castPtr ptr'
castListenerQDockWidgetFeaturesToNonconst (ListenerQDockWidgetFeaturesConstGc fptr' ptr') = ListenerQDockWidgetFeaturesGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQDockWidgetFeatures where
nullptr = ListenerQDockWidgetFeatures HoppyF.nullPtr
withCppPtr (ListenerQDockWidgetFeatures ptr') f' = f' ptr'
withCppPtr (ListenerQDockWidgetFeaturesGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQDockWidgetFeatures ptr') = ptr'
toPtr (ListenerQDockWidgetFeaturesGc _ ptr') = ptr'
touchCppPtr (ListenerQDockWidgetFeatures _) = HoppyP.return ()
touchCppPtr (ListenerQDockWidgetFeaturesGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQDockWidgetFeatures where
delete (ListenerQDockWidgetFeatures ptr') = delete'ListenerQDockWidgetFeatures $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQDockWidgetFeaturesConst)
delete (ListenerQDockWidgetFeaturesGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQDockWidgetFeatures", " object."]
toGc this'@(ListenerQDockWidgetFeatures ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQDockWidgetFeaturesGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQDockWidgetFeatures :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQDockWidgetFeaturesGc {}) = HoppyP.return this'
instance ListenerQDockWidgetFeaturesConstPtr ListenerQDockWidgetFeatures where
toListenerQDockWidgetFeaturesConst (ListenerQDockWidgetFeatures ptr') = ListenerQDockWidgetFeaturesConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
toListenerQDockWidgetFeaturesConst (ListenerQDockWidgetFeaturesGc fptr' ptr') = ListenerQDockWidgetFeaturesConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
instance ListenerQDockWidgetFeaturesPtr ListenerQDockWidgetFeatures where
toListenerQDockWidgetFeatures = HoppyP.id
instance M34.QObjectConstPtr ListenerQDockWidgetFeatures where
toQObjectConst (ListenerQDockWidgetFeatures ptr') = M34.QObjectConst $ castListenerQDockWidgetFeaturesToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
toQObjectConst (ListenerQDockWidgetFeaturesGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQDockWidgetFeaturesToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
instance M34.QObjectPtr ListenerQDockWidgetFeatures where
toQObject (ListenerQDockWidgetFeatures ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQDockWidgetFeaturesToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
toQObject (ListenerQDockWidgetFeaturesGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQDockWidgetFeaturesToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQDockWidgetFeatures -> HoppyF.Ptr ListenerQDockWidgetFeaturesConst) ptr'
listenerQDockWidgetFeatures_new :: (M224.QDockWidgetDockWidgetFeatures -> HoppyP.IO ()) -> HoppyP.IO ListenerQDockWidgetFeatures
listenerQDockWidgetFeatures_new arg'1 =
M182.callbackQDockWidgetFeaturesVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQDockWidgetFeatures
(listenerQDockWidgetFeatures_new' arg'1')
listenerQDockWidgetFeatures_newWithParent :: (M34.QObjectPtr arg'2) => (M224.QDockWidgetDockWidgetFeatures -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQDockWidgetFeatures
listenerQDockWidgetFeatures_newWithParent arg'1 arg'2 =
M182.callbackQDockWidgetFeaturesVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQDockWidgetFeatures
(listenerQDockWidgetFeatures_newWithParent' arg'1' arg'2')
class ListenerQDockWidgetFeaturesSuper a where
downToListenerQDockWidgetFeatures :: a -> ListenerQDockWidgetFeatures
instance ListenerQDockWidgetFeaturesSuper M34.QObject where
downToListenerQDockWidgetFeatures = castListenerQDockWidgetFeaturesToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQDockWidgetFeaturesConst $ castQObjectToListenerQDockWidgetFeatures ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQDockWidgetFeaturesConstGc fptr' $ castQObjectToListenerQDockWidgetFeatures ptr'
class ListenerQDockWidgetFeaturesSuperConst a where
downToListenerQDockWidgetFeaturesConst :: a -> ListenerQDockWidgetFeaturesConst
instance ListenerQDockWidgetFeaturesSuperConst M34.QObjectConst where
downToListenerQDockWidgetFeaturesConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQDockWidgetFeaturesConst $ castQObjectToListenerQDockWidgetFeatures ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQDockWidgetFeaturesConstGc fptr' $ castQObjectToListenerQDockWidgetFeatures ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQDockWidgetFeatures)) ListenerQDockWidgetFeatures where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQDockWidgetFeatures)) ListenerQDockWidgetFeatures where
decode = HoppyP.fmap ListenerQDockWidgetFeatures . HoppyF.peek
class ListenerQModelIndexValue a where
withListenerQModelIndexPtr :: a -> (ListenerQModelIndexConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQModelIndexConstPtr a => ListenerQModelIndexValue a where
withListenerQModelIndexPtr = HoppyP.flip ($) . toListenerQModelIndexConst
class (M34.QObjectConstPtr this) => ListenerQModelIndexConstPtr this where
toListenerQModelIndexConst :: this -> ListenerQModelIndexConst
class (ListenerQModelIndexConstPtr this, M34.QObjectPtr this) => ListenerQModelIndexPtr this where
toListenerQModelIndex :: this -> ListenerQModelIndex
listenerQModelIndex_connectListener :: (ListenerQModelIndexPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQModelIndex_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQModelIndex arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQModelIndex_connectListener' arg'1' arg'2' arg'3')
data ListenerQModelIndexConst =
ListenerQModelIndexConst (HoppyF.Ptr ListenerQModelIndexConst)
| ListenerQModelIndexConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexToConst :: ListenerQModelIndex -> ListenerQModelIndexConst
castListenerQModelIndexToConst (ListenerQModelIndex ptr') = ListenerQModelIndexConst $ HoppyF.castPtr ptr'
castListenerQModelIndexToConst (ListenerQModelIndexGc fptr' ptr') = ListenerQModelIndexConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexConst where
nullptr = ListenerQModelIndexConst HoppyF.nullPtr
withCppPtr (ListenerQModelIndexConst ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexConst ptr') = ptr'
toPtr (ListenerQModelIndexConstGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexConst _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexConst where
delete (ListenerQModelIndexConst ptr') = delete'ListenerQModelIndex ptr'
delete (ListenerQModelIndexConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexConst", " object."]
toGc this'@(ListenerQModelIndexConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexConstGc {}) = HoppyP.return this'
instance ListenerQModelIndexConstPtr ListenerQModelIndexConst where
toListenerQModelIndexConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexConst where
toQObjectConst (ListenerQModelIndexConst ptr') = M34.QObjectConst $ castListenerQModelIndexToQObject ptr'
toQObjectConst (ListenerQModelIndexConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexToQObject ptr'
data ListenerQModelIndex =
ListenerQModelIndex (HoppyF.Ptr ListenerQModelIndex)
| ListenerQModelIndexGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndex)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndex where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndex where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexToNonconst :: ListenerQModelIndexConst -> ListenerQModelIndex
castListenerQModelIndexToNonconst (ListenerQModelIndexConst ptr') = ListenerQModelIndex $ HoppyF.castPtr ptr'
castListenerQModelIndexToNonconst (ListenerQModelIndexConstGc fptr' ptr') = ListenerQModelIndexGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndex where
nullptr = ListenerQModelIndex HoppyF.nullPtr
withCppPtr (ListenerQModelIndex ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndex ptr') = ptr'
toPtr (ListenerQModelIndexGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndex _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndex where
delete (ListenerQModelIndex ptr') = delete'ListenerQModelIndex $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQModelIndexConst)
delete (ListenerQModelIndexGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndex", " object."]
toGc this'@(ListenerQModelIndex ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexGc {}) = HoppyP.return this'
instance ListenerQModelIndexConstPtr ListenerQModelIndex where
toListenerQModelIndexConst (ListenerQModelIndex ptr') = ListenerQModelIndexConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
toListenerQModelIndexConst (ListenerQModelIndexGc fptr' ptr') = ListenerQModelIndexConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
instance ListenerQModelIndexPtr ListenerQModelIndex where
toListenerQModelIndex = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndex where
toQObjectConst (ListenerQModelIndex ptr') = M34.QObjectConst $ castListenerQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
toQObjectConst (ListenerQModelIndexGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
instance M34.QObjectPtr ListenerQModelIndex where
toQObject (ListenerQModelIndex ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
toQObject (ListenerQModelIndexGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndex -> HoppyF.Ptr ListenerQModelIndexConst) ptr'
listenerQModelIndex_new :: (M32.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO ListenerQModelIndex
listenerQModelIndex_new arg'1 =
M182.callbackQModelIndexVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQModelIndex
(listenerQModelIndex_new' arg'1')
listenerQModelIndex_newWithParent :: (M34.QObjectPtr arg'2) => (M32.QModelIndex -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQModelIndex
listenerQModelIndex_newWithParent arg'1 arg'2 =
M182.callbackQModelIndexVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQModelIndex
(listenerQModelIndex_newWithParent' arg'1' arg'2')
class ListenerQModelIndexSuper a where
downToListenerQModelIndex :: a -> ListenerQModelIndex
instance ListenerQModelIndexSuper M34.QObject where
downToListenerQModelIndex = castListenerQModelIndexToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexConst $ castQObjectToListenerQModelIndex ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexConstGc fptr' $ castQObjectToListenerQModelIndex ptr'
class ListenerQModelIndexSuperConst a where
downToListenerQModelIndexConst :: a -> ListenerQModelIndexConst
instance ListenerQModelIndexSuperConst M34.QObjectConst where
downToListenerQModelIndexConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexConst $ castQObjectToListenerQModelIndex ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexConstGc fptr' $ castQObjectToListenerQModelIndex ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndex)) ListenerQModelIndex where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndex)) ListenerQModelIndex where
decode = HoppyP.fmap ListenerQModelIndex . HoppyF.peek
class ListenerQModelIndexIntIntValue a where
withListenerQModelIndexIntIntPtr :: a -> (ListenerQModelIndexIntIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQModelIndexIntIntConstPtr a => ListenerQModelIndexIntIntValue a where
withListenerQModelIndexIntIntPtr = HoppyP.flip ($) . toListenerQModelIndexIntIntConst
class (M34.QObjectConstPtr this) => ListenerQModelIndexIntIntConstPtr this where
toListenerQModelIndexIntIntConst :: this -> ListenerQModelIndexIntIntConst
class (ListenerQModelIndexIntIntConstPtr this, M34.QObjectPtr this) => ListenerQModelIndexIntIntPtr this where
toListenerQModelIndexIntInt :: this -> ListenerQModelIndexIntInt
listenerQModelIndexIntInt_connectListener :: (ListenerQModelIndexIntIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQModelIndexIntInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQModelIndexIntInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQModelIndexIntInt_connectListener' arg'1' arg'2' arg'3')
data ListenerQModelIndexIntIntConst =
ListenerQModelIndexIntIntConst (HoppyF.Ptr ListenerQModelIndexIntIntConst)
| ListenerQModelIndexIntIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexIntIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexIntIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexIntIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexIntIntToConst :: ListenerQModelIndexIntInt -> ListenerQModelIndexIntIntConst
castListenerQModelIndexIntIntToConst (ListenerQModelIndexIntInt ptr') = ListenerQModelIndexIntIntConst $ HoppyF.castPtr ptr'
castListenerQModelIndexIntIntToConst (ListenerQModelIndexIntIntGc fptr' ptr') = ListenerQModelIndexIntIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexIntIntConst where
nullptr = ListenerQModelIndexIntIntConst HoppyF.nullPtr
withCppPtr (ListenerQModelIndexIntIntConst ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexIntIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexIntIntConst ptr') = ptr'
toPtr (ListenerQModelIndexIntIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexIntIntConst _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexIntIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexIntIntConst where
delete (ListenerQModelIndexIntIntConst ptr') = delete'ListenerQModelIndexIntInt ptr'
delete (ListenerQModelIndexIntIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexIntIntConst", " object."]
toGc this'@(ListenerQModelIndexIntIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexIntIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexIntInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexIntIntConstGc {}) = HoppyP.return this'
instance ListenerQModelIndexIntIntConstPtr ListenerQModelIndexIntIntConst where
toListenerQModelIndexIntIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexIntIntConst where
toQObjectConst (ListenerQModelIndexIntIntConst ptr') = M34.QObjectConst $ castListenerQModelIndexIntIntToQObject ptr'
toQObjectConst (ListenerQModelIndexIntIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexIntIntToQObject ptr'
data ListenerQModelIndexIntInt =
ListenerQModelIndexIntInt (HoppyF.Ptr ListenerQModelIndexIntInt)
| ListenerQModelIndexIntIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexIntInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexIntInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexIntInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexIntIntToNonconst :: ListenerQModelIndexIntIntConst -> ListenerQModelIndexIntInt
castListenerQModelIndexIntIntToNonconst (ListenerQModelIndexIntIntConst ptr') = ListenerQModelIndexIntInt $ HoppyF.castPtr ptr'
castListenerQModelIndexIntIntToNonconst (ListenerQModelIndexIntIntConstGc fptr' ptr') = ListenerQModelIndexIntIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexIntInt where
nullptr = ListenerQModelIndexIntInt HoppyF.nullPtr
withCppPtr (ListenerQModelIndexIntInt ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexIntIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexIntInt ptr') = ptr'
toPtr (ListenerQModelIndexIntIntGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexIntInt _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexIntIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexIntInt where
delete (ListenerQModelIndexIntInt ptr') = delete'ListenerQModelIndexIntInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQModelIndexIntIntConst)
delete (ListenerQModelIndexIntIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexIntInt", " object."]
toGc this'@(ListenerQModelIndexIntInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexIntIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexIntInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexIntIntGc {}) = HoppyP.return this'
instance ListenerQModelIndexIntIntConstPtr ListenerQModelIndexIntInt where
toListenerQModelIndexIntIntConst (ListenerQModelIndexIntInt ptr') = ListenerQModelIndexIntIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
toListenerQModelIndexIntIntConst (ListenerQModelIndexIntIntGc fptr' ptr') = ListenerQModelIndexIntIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
instance ListenerQModelIndexIntIntPtr ListenerQModelIndexIntInt where
toListenerQModelIndexIntInt = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexIntInt where
toQObjectConst (ListenerQModelIndexIntInt ptr') = M34.QObjectConst $ castListenerQModelIndexIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
toQObjectConst (ListenerQModelIndexIntIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
instance M34.QObjectPtr ListenerQModelIndexIntInt where
toQObject (ListenerQModelIndexIntInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
toQObject (ListenerQModelIndexIntIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexIntIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntInt -> HoppyF.Ptr ListenerQModelIndexIntIntConst) ptr'
listenerQModelIndexIntInt_new :: (M32.QModelIndex -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO ListenerQModelIndexIntInt
listenerQModelIndexIntInt_new arg'1 =
M182.callbackQModelIndexIntIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQModelIndexIntInt
(listenerQModelIndexIntInt_new' arg'1')
listenerQModelIndexIntInt_newWithParent :: (M34.QObjectPtr arg'2) => (M32.QModelIndex -> HoppyP.Int -> HoppyP.Int -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQModelIndexIntInt
listenerQModelIndexIntInt_newWithParent arg'1 arg'2 =
M182.callbackQModelIndexIntIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQModelIndexIntInt
(listenerQModelIndexIntInt_newWithParent' arg'1' arg'2')
class ListenerQModelIndexIntIntSuper a where
downToListenerQModelIndexIntInt :: a -> ListenerQModelIndexIntInt
instance ListenerQModelIndexIntIntSuper M34.QObject where
downToListenerQModelIndexIntInt = castListenerQModelIndexIntIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexIntIntConst $ castQObjectToListenerQModelIndexIntInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexIntIntConstGc fptr' $ castQObjectToListenerQModelIndexIntInt ptr'
class ListenerQModelIndexIntIntSuperConst a where
downToListenerQModelIndexIntIntConst :: a -> ListenerQModelIndexIntIntConst
instance ListenerQModelIndexIntIntSuperConst M34.QObjectConst where
downToListenerQModelIndexIntIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexIntIntConst $ castQObjectToListenerQModelIndexIntInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexIntIntConstGc fptr' $ castQObjectToListenerQModelIndexIntInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexIntInt)) ListenerQModelIndexIntInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexIntInt)) ListenerQModelIndexIntInt where
decode = HoppyP.fmap ListenerQModelIndexIntInt . HoppyF.peek
class ListenerQModelIndexIntIntQModelIndexIntValue a where
withListenerQModelIndexIntIntQModelIndexIntPtr :: a -> (ListenerQModelIndexIntIntQModelIndexIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQModelIndexIntIntQModelIndexIntConstPtr a => ListenerQModelIndexIntIntQModelIndexIntValue a where
withListenerQModelIndexIntIntQModelIndexIntPtr = HoppyP.flip ($) . toListenerQModelIndexIntIntQModelIndexIntConst
class (M34.QObjectConstPtr this) => ListenerQModelIndexIntIntQModelIndexIntConstPtr this where
toListenerQModelIndexIntIntQModelIndexIntConst :: this -> ListenerQModelIndexIntIntQModelIndexIntConst
class (ListenerQModelIndexIntIntQModelIndexIntConstPtr this, M34.QObjectPtr this) => ListenerQModelIndexIntIntQModelIndexIntPtr this where
toListenerQModelIndexIntIntQModelIndexInt :: this -> ListenerQModelIndexIntIntQModelIndexInt
listenerQModelIndexIntIntQModelIndexInt_connectListener :: (ListenerQModelIndexIntIntQModelIndexIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQModelIndexIntIntQModelIndexInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQModelIndexIntIntQModelIndexInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQModelIndexIntIntQModelIndexInt_connectListener' arg'1' arg'2' arg'3')
data ListenerQModelIndexIntIntQModelIndexIntConst =
ListenerQModelIndexIntIntQModelIndexIntConst (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst)
| ListenerQModelIndexIntIntQModelIndexIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexIntIntQModelIndexIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexIntIntQModelIndexIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexIntIntQModelIndexIntToConst :: ListenerQModelIndexIntIntQModelIndexInt -> ListenerQModelIndexIntIntQModelIndexIntConst
castListenerQModelIndexIntIntQModelIndexIntToConst (ListenerQModelIndexIntIntQModelIndexInt ptr') = ListenerQModelIndexIntIntQModelIndexIntConst $ HoppyF.castPtr ptr'
castListenerQModelIndexIntIntQModelIndexIntToConst (ListenerQModelIndexIntIntQModelIndexIntGc fptr' ptr') = ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexIntIntQModelIndexIntConst where
nullptr = ListenerQModelIndexIntIntQModelIndexIntConst HoppyF.nullPtr
withCppPtr (ListenerQModelIndexIntIntQModelIndexIntConst ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexIntIntQModelIndexIntConst ptr') = ptr'
toPtr (ListenerQModelIndexIntIntQModelIndexIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexIntIntQModelIndexIntConst _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexIntIntQModelIndexIntConst where
delete (ListenerQModelIndexIntIntQModelIndexIntConst ptr') = delete'ListenerQModelIndexIntIntQModelIndexInt ptr'
delete (ListenerQModelIndexIntIntQModelIndexIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexIntIntQModelIndexIntConst", " object."]
toGc this'@(ListenerQModelIndexIntIntQModelIndexIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexIntIntQModelIndexIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexIntIntQModelIndexInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexIntIntQModelIndexIntConstGc {}) = HoppyP.return this'
instance ListenerQModelIndexIntIntQModelIndexIntConstPtr ListenerQModelIndexIntIntQModelIndexIntConst where
toListenerQModelIndexIntIntQModelIndexIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexIntIntQModelIndexIntConst where
toQObjectConst (ListenerQModelIndexIntIntQModelIndexIntConst ptr') = M34.QObjectConst $ castListenerQModelIndexIntIntQModelIndexIntToQObject ptr'
toQObjectConst (ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexIntIntQModelIndexIntToQObject ptr'
data ListenerQModelIndexIntIntQModelIndexInt =
ListenerQModelIndexIntIntQModelIndexInt (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)
| ListenerQModelIndexIntIntQModelIndexIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexIntIntQModelIndexInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexIntIntQModelIndexInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexIntIntQModelIndexIntToNonconst :: ListenerQModelIndexIntIntQModelIndexIntConst -> ListenerQModelIndexIntIntQModelIndexInt
castListenerQModelIndexIntIntQModelIndexIntToNonconst (ListenerQModelIndexIntIntQModelIndexIntConst ptr') = ListenerQModelIndexIntIntQModelIndexInt $ HoppyF.castPtr ptr'
castListenerQModelIndexIntIntQModelIndexIntToNonconst (ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' ptr') = ListenerQModelIndexIntIntQModelIndexIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexIntIntQModelIndexInt where
nullptr = ListenerQModelIndexIntIntQModelIndexInt HoppyF.nullPtr
withCppPtr (ListenerQModelIndexIntIntQModelIndexInt ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexIntIntQModelIndexIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexIntIntQModelIndexInt ptr') = ptr'
toPtr (ListenerQModelIndexIntIntQModelIndexIntGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexIntIntQModelIndexInt _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexIntIntQModelIndexIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexIntIntQModelIndexInt where
delete (ListenerQModelIndexIntIntQModelIndexInt ptr') = delete'ListenerQModelIndexIntIntQModelIndexInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst)
delete (ListenerQModelIndexIntIntQModelIndexIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexIntIntQModelIndexInt", " object."]
toGc this'@(ListenerQModelIndexIntIntQModelIndexInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexIntIntQModelIndexIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexIntIntQModelIndexInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexIntIntQModelIndexIntGc {}) = HoppyP.return this'
instance ListenerQModelIndexIntIntQModelIndexIntConstPtr ListenerQModelIndexIntIntQModelIndexInt where
toListenerQModelIndexIntIntQModelIndexIntConst (ListenerQModelIndexIntIntQModelIndexInt ptr') = ListenerQModelIndexIntIntQModelIndexIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
toListenerQModelIndexIntIntQModelIndexIntConst (ListenerQModelIndexIntIntQModelIndexIntGc fptr' ptr') = ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
instance ListenerQModelIndexIntIntQModelIndexIntPtr ListenerQModelIndexIntIntQModelIndexInt where
toListenerQModelIndexIntIntQModelIndexInt = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexIntIntQModelIndexInt where
toQObjectConst (ListenerQModelIndexIntIntQModelIndexInt ptr') = M34.QObjectConst $ castListenerQModelIndexIntIntQModelIndexIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
toQObjectConst (ListenerQModelIndexIntIntQModelIndexIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexIntIntQModelIndexIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
instance M34.QObjectPtr ListenerQModelIndexIntIntQModelIndexInt where
toQObject (ListenerQModelIndexIntIntQModelIndexInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexIntIntQModelIndexIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
toQObject (ListenerQModelIndexIntIntQModelIndexIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexIntIntQModelIndexIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt -> HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexIntConst) ptr'
listenerQModelIndexIntIntQModelIndexInt_new :: (M32.QModelIndex -> HoppyP.Int -> HoppyP.Int -> M32.QModelIndex -> HoppyP.Int -> HoppyP.IO ()) -> HoppyP.IO ListenerQModelIndexIntIntQModelIndexInt
listenerQModelIndexIntIntQModelIndexInt_new arg'1 =
M182.callbackQModelIndexIntIntQModelIndexIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQModelIndexIntIntQModelIndexInt
(listenerQModelIndexIntIntQModelIndexInt_new' arg'1')
listenerQModelIndexIntIntQModelIndexInt_newWithParent :: (M34.QObjectPtr arg'2) => (M32.QModelIndex -> HoppyP.Int -> HoppyP.Int -> M32.QModelIndex -> HoppyP.Int -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQModelIndexIntIntQModelIndexInt
listenerQModelIndexIntIntQModelIndexInt_newWithParent arg'1 arg'2 =
M182.callbackQModelIndexIntIntQModelIndexIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQModelIndexIntIntQModelIndexInt
(listenerQModelIndexIntIntQModelIndexInt_newWithParent' arg'1' arg'2')
class ListenerQModelIndexIntIntQModelIndexIntSuper a where
downToListenerQModelIndexIntIntQModelIndexInt :: a -> ListenerQModelIndexIntIntQModelIndexInt
instance ListenerQModelIndexIntIntQModelIndexIntSuper M34.QObject where
downToListenerQModelIndexIntIntQModelIndexInt = castListenerQModelIndexIntIntQModelIndexIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexIntIntQModelIndexIntConst $ castQObjectToListenerQModelIndexIntIntQModelIndexInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' $ castQObjectToListenerQModelIndexIntIntQModelIndexInt ptr'
class ListenerQModelIndexIntIntQModelIndexIntSuperConst a where
downToListenerQModelIndexIntIntQModelIndexIntConst :: a -> ListenerQModelIndexIntIntQModelIndexIntConst
instance ListenerQModelIndexIntIntQModelIndexIntSuperConst M34.QObjectConst where
downToListenerQModelIndexIntIntQModelIndexIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexIntIntQModelIndexIntConst $ castQObjectToListenerQModelIndexIntIntQModelIndexInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexIntIntQModelIndexIntConstGc fptr' $ castQObjectToListenerQModelIndexIntIntQModelIndexInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)) ListenerQModelIndexIntIntQModelIndexInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexIntIntQModelIndexInt)) ListenerQModelIndexIntIntQModelIndexInt where
decode = HoppyP.fmap ListenerQModelIndexIntIntQModelIndexInt . HoppyF.peek
class ListenerQModelIndexQModelIndexValue a where
withListenerQModelIndexQModelIndexPtr :: a -> (ListenerQModelIndexQModelIndexConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQModelIndexQModelIndexConstPtr a => ListenerQModelIndexQModelIndexValue a where
withListenerQModelIndexQModelIndexPtr = HoppyP.flip ($) . toListenerQModelIndexQModelIndexConst
class (M34.QObjectConstPtr this) => ListenerQModelIndexQModelIndexConstPtr this where
toListenerQModelIndexQModelIndexConst :: this -> ListenerQModelIndexQModelIndexConst
class (ListenerQModelIndexQModelIndexConstPtr this, M34.QObjectPtr this) => ListenerQModelIndexQModelIndexPtr this where
toListenerQModelIndexQModelIndex :: this -> ListenerQModelIndexQModelIndex
listenerQModelIndexQModelIndex_connectListener :: (ListenerQModelIndexQModelIndexPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQModelIndexQModelIndex_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQModelIndexQModelIndex arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQModelIndexQModelIndex_connectListener' arg'1' arg'2' arg'3')
data ListenerQModelIndexQModelIndexConst =
ListenerQModelIndexQModelIndexConst (HoppyF.Ptr ListenerQModelIndexQModelIndexConst)
| ListenerQModelIndexQModelIndexConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexQModelIndexConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexQModelIndexConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexQModelIndexConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexQModelIndexToConst :: ListenerQModelIndexQModelIndex -> ListenerQModelIndexQModelIndexConst
castListenerQModelIndexQModelIndexToConst (ListenerQModelIndexQModelIndex ptr') = ListenerQModelIndexQModelIndexConst $ HoppyF.castPtr ptr'
castListenerQModelIndexQModelIndexToConst (ListenerQModelIndexQModelIndexGc fptr' ptr') = ListenerQModelIndexQModelIndexConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexQModelIndexConst where
nullptr = ListenerQModelIndexQModelIndexConst HoppyF.nullPtr
withCppPtr (ListenerQModelIndexQModelIndexConst ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexQModelIndexConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexQModelIndexConst ptr') = ptr'
toPtr (ListenerQModelIndexQModelIndexConstGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexQModelIndexConst _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexQModelIndexConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexQModelIndexConst where
delete (ListenerQModelIndexQModelIndexConst ptr') = delete'ListenerQModelIndexQModelIndex ptr'
delete (ListenerQModelIndexQModelIndexConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexQModelIndexConst", " object."]
toGc this'@(ListenerQModelIndexQModelIndexConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexQModelIndexConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexQModelIndexConstGc {}) = HoppyP.return this'
instance ListenerQModelIndexQModelIndexConstPtr ListenerQModelIndexQModelIndexConst where
toListenerQModelIndexQModelIndexConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexQModelIndexConst where
toQObjectConst (ListenerQModelIndexQModelIndexConst ptr') = M34.QObjectConst $ castListenerQModelIndexQModelIndexToQObject ptr'
toQObjectConst (ListenerQModelIndexQModelIndexConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexQModelIndexToQObject ptr'
data ListenerQModelIndexQModelIndex =
ListenerQModelIndexQModelIndex (HoppyF.Ptr ListenerQModelIndexQModelIndex)
| ListenerQModelIndexQModelIndexGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexQModelIndex)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexQModelIndex where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexQModelIndex where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexQModelIndexToNonconst :: ListenerQModelIndexQModelIndexConst -> ListenerQModelIndexQModelIndex
castListenerQModelIndexQModelIndexToNonconst (ListenerQModelIndexQModelIndexConst ptr') = ListenerQModelIndexQModelIndex $ HoppyF.castPtr ptr'
castListenerQModelIndexQModelIndexToNonconst (ListenerQModelIndexQModelIndexConstGc fptr' ptr') = ListenerQModelIndexQModelIndexGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexQModelIndex where
nullptr = ListenerQModelIndexQModelIndex HoppyF.nullPtr
withCppPtr (ListenerQModelIndexQModelIndex ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexQModelIndexGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexQModelIndex ptr') = ptr'
toPtr (ListenerQModelIndexQModelIndexGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexQModelIndex _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexQModelIndexGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexQModelIndex where
delete (ListenerQModelIndexQModelIndex ptr') = delete'ListenerQModelIndexQModelIndex $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQModelIndexQModelIndexConst)
delete (ListenerQModelIndexQModelIndexGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexQModelIndex", " object."]
toGc this'@(ListenerQModelIndexQModelIndex ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexQModelIndexGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexQModelIndex :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexQModelIndexGc {}) = HoppyP.return this'
instance ListenerQModelIndexQModelIndexConstPtr ListenerQModelIndexQModelIndex where
toListenerQModelIndexQModelIndexConst (ListenerQModelIndexQModelIndex ptr') = ListenerQModelIndexQModelIndexConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
toListenerQModelIndexQModelIndexConst (ListenerQModelIndexQModelIndexGc fptr' ptr') = ListenerQModelIndexQModelIndexConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
instance ListenerQModelIndexQModelIndexPtr ListenerQModelIndexQModelIndex where
toListenerQModelIndexQModelIndex = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexQModelIndex where
toQObjectConst (ListenerQModelIndexQModelIndex ptr') = M34.QObjectConst $ castListenerQModelIndexQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
toQObjectConst (ListenerQModelIndexQModelIndexGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
instance M34.QObjectPtr ListenerQModelIndexQModelIndex where
toQObject (ListenerQModelIndexQModelIndex ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
toQObject (ListenerQModelIndexQModelIndexGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexQModelIndexToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndex -> HoppyF.Ptr ListenerQModelIndexQModelIndexConst) ptr'
listenerQModelIndexQModelIndex_new :: (M32.QModelIndex -> M32.QModelIndex -> HoppyP.IO ()) -> HoppyP.IO ListenerQModelIndexQModelIndex
listenerQModelIndexQModelIndex_new arg'1 =
M182.callbackQModelIndexQModelIndexVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQModelIndexQModelIndex
(listenerQModelIndexQModelIndex_new' arg'1')
listenerQModelIndexQModelIndex_newWithParent :: (M34.QObjectPtr arg'2) => (M32.QModelIndex -> M32.QModelIndex -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQModelIndexQModelIndex
listenerQModelIndexQModelIndex_newWithParent arg'1 arg'2 =
M182.callbackQModelIndexQModelIndexVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQModelIndexQModelIndex
(listenerQModelIndexQModelIndex_newWithParent' arg'1' arg'2')
class ListenerQModelIndexQModelIndexSuper a where
downToListenerQModelIndexQModelIndex :: a -> ListenerQModelIndexQModelIndex
instance ListenerQModelIndexQModelIndexSuper M34.QObject where
downToListenerQModelIndexQModelIndex = castListenerQModelIndexQModelIndexToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexQModelIndexConst $ castQObjectToListenerQModelIndexQModelIndex ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexQModelIndexConstGc fptr' $ castQObjectToListenerQModelIndexQModelIndex ptr'
class ListenerQModelIndexQModelIndexSuperConst a where
downToListenerQModelIndexQModelIndexConst :: a -> ListenerQModelIndexQModelIndexConst
instance ListenerQModelIndexQModelIndexSuperConst M34.QObjectConst where
downToListenerQModelIndexQModelIndexConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexQModelIndexConst $ castQObjectToListenerQModelIndexQModelIndex ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexQModelIndexConstGc fptr' $ castQObjectToListenerQModelIndexQModelIndex ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexQModelIndex)) ListenerQModelIndexQModelIndex where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexQModelIndex)) ListenerQModelIndexQModelIndex where
decode = HoppyP.fmap ListenerQModelIndexQModelIndex . HoppyF.peek
class ListenerQModelIndexQModelIndexQVectorIntValue a where
withListenerQModelIndexQModelIndexQVectorIntPtr :: a -> (ListenerQModelIndexQModelIndexQVectorIntConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQModelIndexQModelIndexQVectorIntConstPtr a => ListenerQModelIndexQModelIndexQVectorIntValue a where
withListenerQModelIndexQModelIndexQVectorIntPtr = HoppyP.flip ($) . toListenerQModelIndexQModelIndexQVectorIntConst
class (M34.QObjectConstPtr this) => ListenerQModelIndexQModelIndexQVectorIntConstPtr this where
toListenerQModelIndexQModelIndexQVectorIntConst :: this -> ListenerQModelIndexQModelIndexQVectorIntConst
class (ListenerQModelIndexQModelIndexQVectorIntConstPtr this, M34.QObjectPtr this) => ListenerQModelIndexQModelIndexQVectorIntPtr this where
toListenerQModelIndexQModelIndexQVectorInt :: this -> ListenerQModelIndexQModelIndexQVectorInt
listenerQModelIndexQModelIndexQVectorInt_connectListener :: (ListenerQModelIndexQModelIndexQVectorIntPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQModelIndexQModelIndexQVectorInt_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQModelIndexQModelIndexQVectorInt arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQModelIndexQModelIndexQVectorInt_connectListener' arg'1' arg'2' arg'3')
data ListenerQModelIndexQModelIndexQVectorIntConst =
ListenerQModelIndexQModelIndexQVectorIntConst (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst)
| ListenerQModelIndexQModelIndexQVectorIntConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexQModelIndexQVectorIntConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexQModelIndexQVectorIntConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexQModelIndexQVectorIntToConst :: ListenerQModelIndexQModelIndexQVectorInt -> ListenerQModelIndexQModelIndexQVectorIntConst
castListenerQModelIndexQModelIndexQVectorIntToConst (ListenerQModelIndexQModelIndexQVectorInt ptr') = ListenerQModelIndexQModelIndexQVectorIntConst $ HoppyF.castPtr ptr'
castListenerQModelIndexQModelIndexQVectorIntToConst (ListenerQModelIndexQModelIndexQVectorIntGc fptr' ptr') = ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexQModelIndexQVectorIntConst where
nullptr = ListenerQModelIndexQModelIndexQVectorIntConst HoppyF.nullPtr
withCppPtr (ListenerQModelIndexQModelIndexQVectorIntConst ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexQModelIndexQVectorIntConst ptr') = ptr'
toPtr (ListenerQModelIndexQModelIndexQVectorIntConstGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexQModelIndexQVectorIntConst _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexQModelIndexQVectorIntConst where
delete (ListenerQModelIndexQModelIndexQVectorIntConst ptr') = delete'ListenerQModelIndexQModelIndexQVectorInt ptr'
delete (ListenerQModelIndexQModelIndexQVectorIntConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexQModelIndexQVectorIntConst", " object."]
toGc this'@(ListenerQModelIndexQModelIndexQVectorIntConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexQModelIndexQVectorIntConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexQModelIndexQVectorInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexQModelIndexQVectorIntConstGc {}) = HoppyP.return this'
instance ListenerQModelIndexQModelIndexQVectorIntConstPtr ListenerQModelIndexQModelIndexQVectorIntConst where
toListenerQModelIndexQModelIndexQVectorIntConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexQModelIndexQVectorIntConst where
toQObjectConst (ListenerQModelIndexQModelIndexQVectorIntConst ptr') = M34.QObjectConst $ castListenerQModelIndexQModelIndexQVectorIntToQObject ptr'
toQObjectConst (ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexQModelIndexQVectorIntToQObject ptr'
data ListenerQModelIndexQModelIndexQVectorInt =
ListenerQModelIndexQModelIndexQVectorInt (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)
| ListenerQModelIndexQModelIndexQVectorIntGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQModelIndexQModelIndexQVectorInt where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQModelIndexQModelIndexQVectorInt where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQModelIndexQModelIndexQVectorIntToNonconst :: ListenerQModelIndexQModelIndexQVectorIntConst -> ListenerQModelIndexQModelIndexQVectorInt
castListenerQModelIndexQModelIndexQVectorIntToNonconst (ListenerQModelIndexQModelIndexQVectorIntConst ptr') = ListenerQModelIndexQModelIndexQVectorInt $ HoppyF.castPtr ptr'
castListenerQModelIndexQModelIndexQVectorIntToNonconst (ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' ptr') = ListenerQModelIndexQModelIndexQVectorIntGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQModelIndexQModelIndexQVectorInt where
nullptr = ListenerQModelIndexQModelIndexQVectorInt HoppyF.nullPtr
withCppPtr (ListenerQModelIndexQModelIndexQVectorInt ptr') f' = f' ptr'
withCppPtr (ListenerQModelIndexQModelIndexQVectorIntGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQModelIndexQModelIndexQVectorInt ptr') = ptr'
toPtr (ListenerQModelIndexQModelIndexQVectorIntGc _ ptr') = ptr'
touchCppPtr (ListenerQModelIndexQModelIndexQVectorInt _) = HoppyP.return ()
touchCppPtr (ListenerQModelIndexQModelIndexQVectorIntGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQModelIndexQModelIndexQVectorInt where
delete (ListenerQModelIndexQModelIndexQVectorInt ptr') = delete'ListenerQModelIndexQModelIndexQVectorInt $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst)
delete (ListenerQModelIndexQModelIndexQVectorIntGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQModelIndexQModelIndexQVectorInt", " object."]
toGc this'@(ListenerQModelIndexQModelIndexQVectorInt ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQModelIndexQModelIndexQVectorIntGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQModelIndexQModelIndexQVectorInt :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQModelIndexQModelIndexQVectorIntGc {}) = HoppyP.return this'
instance ListenerQModelIndexQModelIndexQVectorIntConstPtr ListenerQModelIndexQModelIndexQVectorInt where
toListenerQModelIndexQModelIndexQVectorIntConst (ListenerQModelIndexQModelIndexQVectorInt ptr') = ListenerQModelIndexQModelIndexQVectorIntConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
toListenerQModelIndexQModelIndexQVectorIntConst (ListenerQModelIndexQModelIndexQVectorIntGc fptr' ptr') = ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
instance ListenerQModelIndexQModelIndexQVectorIntPtr ListenerQModelIndexQModelIndexQVectorInt where
toListenerQModelIndexQModelIndexQVectorInt = HoppyP.id
instance M34.QObjectConstPtr ListenerQModelIndexQModelIndexQVectorInt where
toQObjectConst (ListenerQModelIndexQModelIndexQVectorInt ptr') = M34.QObjectConst $ castListenerQModelIndexQModelIndexQVectorIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
toQObjectConst (ListenerQModelIndexQModelIndexQVectorIntGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQModelIndexQModelIndexQVectorIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
instance M34.QObjectPtr ListenerQModelIndexQModelIndexQVectorInt where
toQObject (ListenerQModelIndexQModelIndexQVectorInt ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexQModelIndexQVectorIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
toQObject (ListenerQModelIndexQModelIndexQVectorIntGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQModelIndexQModelIndexQVectorIntToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt -> HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorIntConst) ptr'
listenerQModelIndexQModelIndexQVectorInt_new :: (M32.QModelIndex -> M32.QModelIndex -> M90.QVectorInt -> HoppyP.IO ()) -> HoppyP.IO ListenerQModelIndexQModelIndexQVectorInt
listenerQModelIndexQModelIndexQVectorInt_new arg'1 =
M182.callbackQModelIndexQModelIndexQVectorIntVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQModelIndexQModelIndexQVectorInt
(listenerQModelIndexQModelIndexQVectorInt_new' arg'1')
listenerQModelIndexQModelIndexQVectorInt_newWithParent :: (M34.QObjectPtr arg'2) => (M32.QModelIndex -> M32.QModelIndex -> M90.QVectorInt -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQModelIndexQModelIndexQVectorInt
listenerQModelIndexQModelIndexQVectorInt_newWithParent arg'1 arg'2 =
M182.callbackQModelIndexQModelIndexQVectorIntVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQModelIndexQModelIndexQVectorInt
(listenerQModelIndexQModelIndexQVectorInt_newWithParent' arg'1' arg'2')
class ListenerQModelIndexQModelIndexQVectorIntSuper a where
downToListenerQModelIndexQModelIndexQVectorInt :: a -> ListenerQModelIndexQModelIndexQVectorInt
instance ListenerQModelIndexQModelIndexQVectorIntSuper M34.QObject where
downToListenerQModelIndexQModelIndexQVectorInt = castListenerQModelIndexQModelIndexQVectorIntToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexQModelIndexQVectorIntConst $ castQObjectToListenerQModelIndexQModelIndexQVectorInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' $ castQObjectToListenerQModelIndexQModelIndexQVectorInt ptr'
class ListenerQModelIndexQModelIndexQVectorIntSuperConst a where
downToListenerQModelIndexQModelIndexQVectorIntConst :: a -> ListenerQModelIndexQModelIndexQVectorIntConst
instance ListenerQModelIndexQModelIndexQVectorIntSuperConst M34.QObjectConst where
downToListenerQModelIndexQModelIndexQVectorIntConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQModelIndexQModelIndexQVectorIntConst $ castQObjectToListenerQModelIndexQModelIndexQVectorInt ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQModelIndexQModelIndexQVectorIntConstGc fptr' $ castQObjectToListenerQModelIndexQModelIndexQVectorInt ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)) ListenerQModelIndexQModelIndexQVectorInt where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQModelIndexQModelIndexQVectorInt)) ListenerQModelIndexQModelIndexQVectorInt where
decode = HoppyP.fmap ListenerQModelIndexQModelIndexQVectorInt . HoppyF.peek
class ListenerQPointValue a where
withListenerQPointPtr :: a -> (ListenerQPointConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQPointConstPtr a => ListenerQPointValue a where
withListenerQPointPtr = HoppyP.flip ($) . toListenerQPointConst
class (M34.QObjectConstPtr this) => ListenerQPointConstPtr this where
toListenerQPointConst :: this -> ListenerQPointConst
class (ListenerQPointConstPtr this, M34.QObjectPtr this) => ListenerQPointPtr this where
toListenerQPoint :: this -> ListenerQPoint
listenerQPoint_connectListener :: (ListenerQPointPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQPoint_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQPoint arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQPoint_connectListener' arg'1' arg'2' arg'3')
data ListenerQPointConst =
ListenerQPointConst (HoppyF.Ptr ListenerQPointConst)
| ListenerQPointConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQPointConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQPointConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQPointConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQPointToConst :: ListenerQPoint -> ListenerQPointConst
castListenerQPointToConst (ListenerQPoint ptr') = ListenerQPointConst $ HoppyF.castPtr ptr'
castListenerQPointToConst (ListenerQPointGc fptr' ptr') = ListenerQPointConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQPointConst where
nullptr = ListenerQPointConst HoppyF.nullPtr
withCppPtr (ListenerQPointConst ptr') f' = f' ptr'
withCppPtr (ListenerQPointConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQPointConst ptr') = ptr'
toPtr (ListenerQPointConstGc _ ptr') = ptr'
touchCppPtr (ListenerQPointConst _) = HoppyP.return ()
touchCppPtr (ListenerQPointConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQPointConst where
delete (ListenerQPointConst ptr') = delete'ListenerQPoint ptr'
delete (ListenerQPointConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQPointConst", " object."]
toGc this'@(ListenerQPointConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQPointConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQPoint :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQPointConstGc {}) = HoppyP.return this'
instance ListenerQPointConstPtr ListenerQPointConst where
toListenerQPointConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQPointConst where
toQObjectConst (ListenerQPointConst ptr') = M34.QObjectConst $ castListenerQPointToQObject ptr'
toQObjectConst (ListenerQPointConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQPointToQObject ptr'
data ListenerQPoint =
ListenerQPoint (HoppyF.Ptr ListenerQPoint)
| ListenerQPointGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQPoint)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQPoint where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQPoint where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQPointToNonconst :: ListenerQPointConst -> ListenerQPoint
castListenerQPointToNonconst (ListenerQPointConst ptr') = ListenerQPoint $ HoppyF.castPtr ptr'
castListenerQPointToNonconst (ListenerQPointConstGc fptr' ptr') = ListenerQPointGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQPoint where
nullptr = ListenerQPoint HoppyF.nullPtr
withCppPtr (ListenerQPoint ptr') f' = f' ptr'
withCppPtr (ListenerQPointGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQPoint ptr') = ptr'
toPtr (ListenerQPointGc _ ptr') = ptr'
touchCppPtr (ListenerQPoint _) = HoppyP.return ()
touchCppPtr (ListenerQPointGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQPoint where
delete (ListenerQPoint ptr') = delete'ListenerQPoint $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQPointConst)
delete (ListenerQPointGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQPoint", " object."]
toGc this'@(ListenerQPoint ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQPointGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQPoint :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQPointGc {}) = HoppyP.return this'
instance ListenerQPointConstPtr ListenerQPoint where
toListenerQPointConst (ListenerQPoint ptr') = ListenerQPointConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
toListenerQPointConst (ListenerQPointGc fptr' ptr') = ListenerQPointConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
instance ListenerQPointPtr ListenerQPoint where
toListenerQPoint = HoppyP.id
instance M34.QObjectConstPtr ListenerQPoint where
toQObjectConst (ListenerQPoint ptr') = M34.QObjectConst $ castListenerQPointToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
toQObjectConst (ListenerQPointGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQPointToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
instance M34.QObjectPtr ListenerQPoint where
toQObject (ListenerQPoint ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQPointToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
toQObject (ListenerQPointGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQPointToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQPoint -> HoppyF.Ptr ListenerQPointConst) ptr'
listenerQPoint_new :: (HPoint.HPoint -> HoppyP.IO ()) -> HoppyP.IO ListenerQPoint
listenerQPoint_new arg'1 =
M182.callbackQPointVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQPoint
(listenerQPoint_new' arg'1')
listenerQPoint_newWithParent :: (M34.QObjectPtr arg'2) => (HPoint.HPoint -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQPoint
listenerQPoint_newWithParent arg'1 arg'2 =
M182.callbackQPointVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQPoint
(listenerQPoint_newWithParent' arg'1' arg'2')
class ListenerQPointSuper a where
downToListenerQPoint :: a -> ListenerQPoint
instance ListenerQPointSuper M34.QObject where
downToListenerQPoint = castListenerQPointToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQPointConst $ castQObjectToListenerQPoint ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQPointConstGc fptr' $ castQObjectToListenerQPoint ptr'
class ListenerQPointSuperConst a where
downToListenerQPointConst :: a -> ListenerQPointConst
instance ListenerQPointSuperConst M34.QObjectConst where
downToListenerQPointConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQPointConst $ castQObjectToListenerQPoint ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQPointConstGc fptr' $ castQObjectToListenerQPoint ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQPoint)) ListenerQPoint where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQPoint)) ListenerQPoint where
decode = HoppyP.fmap ListenerQPoint . HoppyF.peek
class ListenerQSizeValue a where
withListenerQSizePtr :: a -> (ListenerQSizeConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQSizeConstPtr a => ListenerQSizeValue a where
withListenerQSizePtr = HoppyP.flip ($) . toListenerQSizeConst
class (M34.QObjectConstPtr this) => ListenerQSizeConstPtr this where
toListenerQSizeConst :: this -> ListenerQSizeConst
class (ListenerQSizeConstPtr this, M34.QObjectPtr this) => ListenerQSizePtr this where
toListenerQSize :: this -> ListenerQSize
listenerQSize_connectListener :: (ListenerQSizePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQSize_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQSize arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQSize_connectListener' arg'1' arg'2' arg'3')
data ListenerQSizeConst =
ListenerQSizeConst (HoppyF.Ptr ListenerQSizeConst)
| ListenerQSizeConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQSizeConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQSizeConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQSizeConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQSizeToConst :: ListenerQSize -> ListenerQSizeConst
castListenerQSizeToConst (ListenerQSize ptr') = ListenerQSizeConst $ HoppyF.castPtr ptr'
castListenerQSizeToConst (ListenerQSizeGc fptr' ptr') = ListenerQSizeConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQSizeConst where
nullptr = ListenerQSizeConst HoppyF.nullPtr
withCppPtr (ListenerQSizeConst ptr') f' = f' ptr'
withCppPtr (ListenerQSizeConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQSizeConst ptr') = ptr'
toPtr (ListenerQSizeConstGc _ ptr') = ptr'
touchCppPtr (ListenerQSizeConst _) = HoppyP.return ()
touchCppPtr (ListenerQSizeConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQSizeConst where
delete (ListenerQSizeConst ptr') = delete'ListenerQSize ptr'
delete (ListenerQSizeConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQSizeConst", " object."]
toGc this'@(ListenerQSizeConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQSizeConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQSize :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQSizeConstGc {}) = HoppyP.return this'
instance ListenerQSizeConstPtr ListenerQSizeConst where
toListenerQSizeConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQSizeConst where
toQObjectConst (ListenerQSizeConst ptr') = M34.QObjectConst $ castListenerQSizeToQObject ptr'
toQObjectConst (ListenerQSizeConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQSizeToQObject ptr'
data ListenerQSize =
ListenerQSize (HoppyF.Ptr ListenerQSize)
| ListenerQSizeGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQSize)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQSize where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQSize where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQSizeToNonconst :: ListenerQSizeConst -> ListenerQSize
castListenerQSizeToNonconst (ListenerQSizeConst ptr') = ListenerQSize $ HoppyF.castPtr ptr'
castListenerQSizeToNonconst (ListenerQSizeConstGc fptr' ptr') = ListenerQSizeGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQSize where
nullptr = ListenerQSize HoppyF.nullPtr
withCppPtr (ListenerQSize ptr') f' = f' ptr'
withCppPtr (ListenerQSizeGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQSize ptr') = ptr'
toPtr (ListenerQSizeGc _ ptr') = ptr'
touchCppPtr (ListenerQSize _) = HoppyP.return ()
touchCppPtr (ListenerQSizeGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQSize where
delete (ListenerQSize ptr') = delete'ListenerQSize $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQSizeConst)
delete (ListenerQSizeGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQSize", " object."]
toGc this'@(ListenerQSize ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQSizeGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQSize :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQSizeGc {}) = HoppyP.return this'
instance ListenerQSizeConstPtr ListenerQSize where
toListenerQSizeConst (ListenerQSize ptr') = ListenerQSizeConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
toListenerQSizeConst (ListenerQSizeGc fptr' ptr') = ListenerQSizeConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
instance ListenerQSizePtr ListenerQSize where
toListenerQSize = HoppyP.id
instance M34.QObjectConstPtr ListenerQSize where
toQObjectConst (ListenerQSize ptr') = M34.QObjectConst $ castListenerQSizeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
toQObjectConst (ListenerQSizeGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQSizeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
instance M34.QObjectPtr ListenerQSize where
toQObject (ListenerQSize ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQSizeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
toQObject (ListenerQSizeGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQSizeToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSize -> HoppyF.Ptr ListenerQSizeConst) ptr'
listenerQSize_new :: (HSize.HSize -> HoppyP.IO ()) -> HoppyP.IO ListenerQSize
listenerQSize_new arg'1 =
M182.callbackQSizeVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQSize
(listenerQSize_new' arg'1')
listenerQSize_newWithParent :: (M34.QObjectPtr arg'2) => (HSize.HSize -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQSize
listenerQSize_newWithParent arg'1 arg'2 =
M182.callbackQSizeVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQSize
(listenerQSize_newWithParent' arg'1' arg'2')
class ListenerQSizeSuper a where
downToListenerQSize :: a -> ListenerQSize
instance ListenerQSizeSuper M34.QObject where
downToListenerQSize = castListenerQSizeToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQSizeConst $ castQObjectToListenerQSize ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQSizeConstGc fptr' $ castQObjectToListenerQSize ptr'
class ListenerQSizeSuperConst a where
downToListenerQSizeConst :: a -> ListenerQSizeConst
instance ListenerQSizeSuperConst M34.QObjectConst where
downToListenerQSizeConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQSizeConst $ castQObjectToListenerQSize ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQSizeConstGc fptr' $ castQObjectToListenerQSize ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQSize)) ListenerQSize where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQSize)) ListenerQSize where
decode = HoppyP.fmap ListenerQSize . HoppyF.peek
class ListenerQStringValue a where
withListenerQStringPtr :: a -> (ListenerQStringConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQStringConstPtr a => ListenerQStringValue a where
withListenerQStringPtr = HoppyP.flip ($) . toListenerQStringConst
class (M34.QObjectConstPtr this) => ListenerQStringConstPtr this where
toListenerQStringConst :: this -> ListenerQStringConst
class (ListenerQStringConstPtr this, M34.QObjectPtr this) => ListenerQStringPtr this where
toListenerQString :: this -> ListenerQString
listenerQString_connectListener :: (ListenerQStringPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQString_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQString arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQString_connectListener' arg'1' arg'2' arg'3')
data ListenerQStringConst =
ListenerQStringConst (HoppyF.Ptr ListenerQStringConst)
| ListenerQStringConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQStringConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQStringConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQStringConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQStringToConst :: ListenerQString -> ListenerQStringConst
castListenerQStringToConst (ListenerQString ptr') = ListenerQStringConst $ HoppyF.castPtr ptr'
castListenerQStringToConst (ListenerQStringGc fptr' ptr') = ListenerQStringConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQStringConst where
nullptr = ListenerQStringConst HoppyF.nullPtr
withCppPtr (ListenerQStringConst ptr') f' = f' ptr'
withCppPtr (ListenerQStringConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQStringConst ptr') = ptr'
toPtr (ListenerQStringConstGc _ ptr') = ptr'
touchCppPtr (ListenerQStringConst _) = HoppyP.return ()
touchCppPtr (ListenerQStringConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQStringConst where
delete (ListenerQStringConst ptr') = delete'ListenerQString ptr'
delete (ListenerQStringConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQStringConst", " object."]
toGc this'@(ListenerQStringConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQStringConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQString :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQStringConstGc {}) = HoppyP.return this'
instance ListenerQStringConstPtr ListenerQStringConst where
toListenerQStringConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQStringConst where
toQObjectConst (ListenerQStringConst ptr') = M34.QObjectConst $ castListenerQStringToQObject ptr'
toQObjectConst (ListenerQStringConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQStringToQObject ptr'
data ListenerQString =
ListenerQString (HoppyF.Ptr ListenerQString)
| ListenerQStringGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQString)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQString where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQString where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQStringToNonconst :: ListenerQStringConst -> ListenerQString
castListenerQStringToNonconst (ListenerQStringConst ptr') = ListenerQString $ HoppyF.castPtr ptr'
castListenerQStringToNonconst (ListenerQStringConstGc fptr' ptr') = ListenerQStringGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQString where
nullptr = ListenerQString HoppyF.nullPtr
withCppPtr (ListenerQString ptr') f' = f' ptr'
withCppPtr (ListenerQStringGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQString ptr') = ptr'
toPtr (ListenerQStringGc _ ptr') = ptr'
touchCppPtr (ListenerQString _) = HoppyP.return ()
touchCppPtr (ListenerQStringGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQString where
delete (ListenerQString ptr') = delete'ListenerQString $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQStringConst)
delete (ListenerQStringGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQString", " object."]
toGc this'@(ListenerQString ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQStringGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQString :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQStringGc {}) = HoppyP.return this'
instance ListenerQStringConstPtr ListenerQString where
toListenerQStringConst (ListenerQString ptr') = ListenerQStringConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
toListenerQStringConst (ListenerQStringGc fptr' ptr') = ListenerQStringConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
instance ListenerQStringPtr ListenerQString where
toListenerQString = HoppyP.id
instance M34.QObjectConstPtr ListenerQString where
toQObjectConst (ListenerQString ptr') = M34.QObjectConst $ castListenerQStringToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
toQObjectConst (ListenerQStringGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQStringToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
instance M34.QObjectPtr ListenerQString where
toQObject (ListenerQString ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQStringToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
toQObject (ListenerQStringGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQStringToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQString -> HoppyF.Ptr ListenerQStringConst) ptr'
listenerQString_new :: (QtahP.String -> HoppyP.IO ()) -> HoppyP.IO ListenerQString
listenerQString_new arg'1 =
M182.callbackQStringVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQString
(listenerQString_new' arg'1')
listenerQString_newWithParent :: (M34.QObjectPtr arg'2) => (QtahP.String -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQString
listenerQString_newWithParent arg'1 arg'2 =
M182.callbackQStringVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQString
(listenerQString_newWithParent' arg'1' arg'2')
class ListenerQStringSuper a where
downToListenerQString :: a -> ListenerQString
instance ListenerQStringSuper M34.QObject where
downToListenerQString = castListenerQStringToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQStringConst $ castQObjectToListenerQString ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQStringConstGc fptr' $ castQObjectToListenerQString ptr'
class ListenerQStringSuperConst a where
downToListenerQStringConst :: a -> ListenerQStringConst
instance ListenerQStringSuperConst M34.QObjectConst where
downToListenerQStringConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQStringConst $ castQObjectToListenerQString ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQStringConstGc fptr' $ castQObjectToListenerQString ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQString)) ListenerQString where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQString)) ListenerQString where
decode = HoppyP.fmap ListenerQString . HoppyF.peek
class ListenerQSystemTrayIconActivationReasonValue a where
withListenerQSystemTrayIconActivationReasonPtr :: a -> (ListenerQSystemTrayIconActivationReasonConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQSystemTrayIconActivationReasonConstPtr a => ListenerQSystemTrayIconActivationReasonValue a where
withListenerQSystemTrayIconActivationReasonPtr = HoppyP.flip ($) . toListenerQSystemTrayIconActivationReasonConst
class (M34.QObjectConstPtr this) => ListenerQSystemTrayIconActivationReasonConstPtr this where
toListenerQSystemTrayIconActivationReasonConst :: this -> ListenerQSystemTrayIconActivationReasonConst
class (ListenerQSystemTrayIconActivationReasonConstPtr this, M34.QObjectPtr this) => ListenerQSystemTrayIconActivationReasonPtr this where
toListenerQSystemTrayIconActivationReason :: this -> ListenerQSystemTrayIconActivationReason
listenerQSystemTrayIconActivationReason_connectListener :: (ListenerQSystemTrayIconActivationReasonPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQSystemTrayIconActivationReason_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQSystemTrayIconActivationReason arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQSystemTrayIconActivationReason_connectListener' arg'1' arg'2' arg'3')
data ListenerQSystemTrayIconActivationReasonConst =
ListenerQSystemTrayIconActivationReasonConst (HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst)
| ListenerQSystemTrayIconActivationReasonConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQSystemTrayIconActivationReasonConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQSystemTrayIconActivationReasonConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQSystemTrayIconActivationReasonToConst :: ListenerQSystemTrayIconActivationReason -> ListenerQSystemTrayIconActivationReasonConst
castListenerQSystemTrayIconActivationReasonToConst (ListenerQSystemTrayIconActivationReason ptr') = ListenerQSystemTrayIconActivationReasonConst $ HoppyF.castPtr ptr'
castListenerQSystemTrayIconActivationReasonToConst (ListenerQSystemTrayIconActivationReasonGc fptr' ptr') = ListenerQSystemTrayIconActivationReasonConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQSystemTrayIconActivationReasonConst where
nullptr = ListenerQSystemTrayIconActivationReasonConst HoppyF.nullPtr
withCppPtr (ListenerQSystemTrayIconActivationReasonConst ptr') f' = f' ptr'
withCppPtr (ListenerQSystemTrayIconActivationReasonConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQSystemTrayIconActivationReasonConst ptr') = ptr'
toPtr (ListenerQSystemTrayIconActivationReasonConstGc _ ptr') = ptr'
touchCppPtr (ListenerQSystemTrayIconActivationReasonConst _) = HoppyP.return ()
touchCppPtr (ListenerQSystemTrayIconActivationReasonConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQSystemTrayIconActivationReasonConst where
delete (ListenerQSystemTrayIconActivationReasonConst ptr') = delete'ListenerQSystemTrayIconActivationReason ptr'
delete (ListenerQSystemTrayIconActivationReasonConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQSystemTrayIconActivationReasonConst", " object."]
toGc this'@(ListenerQSystemTrayIconActivationReasonConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQSystemTrayIconActivationReasonConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQSystemTrayIconActivationReason :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQSystemTrayIconActivationReasonConstGc {}) = HoppyP.return this'
instance ListenerQSystemTrayIconActivationReasonConstPtr ListenerQSystemTrayIconActivationReasonConst where
toListenerQSystemTrayIconActivationReasonConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQSystemTrayIconActivationReasonConst where
toQObjectConst (ListenerQSystemTrayIconActivationReasonConst ptr') = M34.QObjectConst $ castListenerQSystemTrayIconActivationReasonToQObject ptr'
toQObjectConst (ListenerQSystemTrayIconActivationReasonConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQSystemTrayIconActivationReasonToQObject ptr'
data ListenerQSystemTrayIconActivationReason =
ListenerQSystemTrayIconActivationReason (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)
| ListenerQSystemTrayIconActivationReasonGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQSystemTrayIconActivationReason where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQSystemTrayIconActivationReason where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQSystemTrayIconActivationReasonToNonconst :: ListenerQSystemTrayIconActivationReasonConst -> ListenerQSystemTrayIconActivationReason
castListenerQSystemTrayIconActivationReasonToNonconst (ListenerQSystemTrayIconActivationReasonConst ptr') = ListenerQSystemTrayIconActivationReason $ HoppyF.castPtr ptr'
castListenerQSystemTrayIconActivationReasonToNonconst (ListenerQSystemTrayIconActivationReasonConstGc fptr' ptr') = ListenerQSystemTrayIconActivationReasonGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQSystemTrayIconActivationReason where
nullptr = ListenerQSystemTrayIconActivationReason HoppyF.nullPtr
withCppPtr (ListenerQSystemTrayIconActivationReason ptr') f' = f' ptr'
withCppPtr (ListenerQSystemTrayIconActivationReasonGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQSystemTrayIconActivationReason ptr') = ptr'
toPtr (ListenerQSystemTrayIconActivationReasonGc _ ptr') = ptr'
touchCppPtr (ListenerQSystemTrayIconActivationReason _) = HoppyP.return ()
touchCppPtr (ListenerQSystemTrayIconActivationReasonGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQSystemTrayIconActivationReason where
delete (ListenerQSystemTrayIconActivationReason ptr') = delete'ListenerQSystemTrayIconActivationReason $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst)
delete (ListenerQSystemTrayIconActivationReasonGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQSystemTrayIconActivationReason", " object."]
toGc this'@(ListenerQSystemTrayIconActivationReason ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQSystemTrayIconActivationReasonGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQSystemTrayIconActivationReason :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQSystemTrayIconActivationReasonGc {}) = HoppyP.return this'
instance ListenerQSystemTrayIconActivationReasonConstPtr ListenerQSystemTrayIconActivationReason where
toListenerQSystemTrayIconActivationReasonConst (ListenerQSystemTrayIconActivationReason ptr') = ListenerQSystemTrayIconActivationReasonConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
toListenerQSystemTrayIconActivationReasonConst (ListenerQSystemTrayIconActivationReasonGc fptr' ptr') = ListenerQSystemTrayIconActivationReasonConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
instance ListenerQSystemTrayIconActivationReasonPtr ListenerQSystemTrayIconActivationReason where
toListenerQSystemTrayIconActivationReason = HoppyP.id
instance M34.QObjectConstPtr ListenerQSystemTrayIconActivationReason where
toQObjectConst (ListenerQSystemTrayIconActivationReason ptr') = M34.QObjectConst $ castListenerQSystemTrayIconActivationReasonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
toQObjectConst (ListenerQSystemTrayIconActivationReasonGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQSystemTrayIconActivationReasonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
instance M34.QObjectPtr ListenerQSystemTrayIconActivationReason where
toQObject (ListenerQSystemTrayIconActivationReason ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQSystemTrayIconActivationReasonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
toQObject (ListenerQSystemTrayIconActivationReasonGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQSystemTrayIconActivationReasonToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQSystemTrayIconActivationReason -> HoppyF.Ptr ListenerQSystemTrayIconActivationReasonConst) ptr'
listenerQSystemTrayIconActivationReason_new :: (M310.QSystemTrayIconActivationReason -> HoppyP.IO ()) -> HoppyP.IO ListenerQSystemTrayIconActivationReason
listenerQSystemTrayIconActivationReason_new arg'1 =
M182.callbackQSystemTrayIconActivationReasonVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQSystemTrayIconActivationReason
(listenerQSystemTrayIconActivationReason_new' arg'1')
listenerQSystemTrayIconActivationReason_newWithParent :: (M34.QObjectPtr arg'2) => (M310.QSystemTrayIconActivationReason -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQSystemTrayIconActivationReason
listenerQSystemTrayIconActivationReason_newWithParent arg'1 arg'2 =
M182.callbackQSystemTrayIconActivationReasonVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQSystemTrayIconActivationReason
(listenerQSystemTrayIconActivationReason_newWithParent' arg'1' arg'2')
class ListenerQSystemTrayIconActivationReasonSuper a where
downToListenerQSystemTrayIconActivationReason :: a -> ListenerQSystemTrayIconActivationReason
instance ListenerQSystemTrayIconActivationReasonSuper M34.QObject where
downToListenerQSystemTrayIconActivationReason = castListenerQSystemTrayIconActivationReasonToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQSystemTrayIconActivationReasonConst $ castQObjectToListenerQSystemTrayIconActivationReason ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQSystemTrayIconActivationReasonConstGc fptr' $ castQObjectToListenerQSystemTrayIconActivationReason ptr'
class ListenerQSystemTrayIconActivationReasonSuperConst a where
downToListenerQSystemTrayIconActivationReasonConst :: a -> ListenerQSystemTrayIconActivationReasonConst
instance ListenerQSystemTrayIconActivationReasonSuperConst M34.QObjectConst where
downToListenerQSystemTrayIconActivationReasonConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQSystemTrayIconActivationReasonConst $ castQObjectToListenerQSystemTrayIconActivationReason ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQSystemTrayIconActivationReasonConstGc fptr' $ castQObjectToListenerQSystemTrayIconActivationReason ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)) ListenerQSystemTrayIconActivationReason where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQSystemTrayIconActivationReason)) ListenerQSystemTrayIconActivationReason where
decode = HoppyP.fmap ListenerQSystemTrayIconActivationReason . HoppyF.peek
class ListenerQWindowVisibilityValue a where
withListenerQWindowVisibilityPtr :: a -> (ListenerQWindowVisibilityConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQWindowVisibilityConstPtr a => ListenerQWindowVisibilityValue a where
withListenerQWindowVisibilityPtr = HoppyP.flip ($) . toListenerQWindowVisibilityConst
class (M34.QObjectConstPtr this) => ListenerQWindowVisibilityConstPtr this where
toListenerQWindowVisibilityConst :: this -> ListenerQWindowVisibilityConst
class (ListenerQWindowVisibilityConstPtr this, M34.QObjectPtr this) => ListenerQWindowVisibilityPtr this where
toListenerQWindowVisibility :: this -> ListenerQWindowVisibility
listenerQWindowVisibility_connectListener :: (ListenerQWindowVisibilityPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQWindowVisibility_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQWindowVisibility arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQWindowVisibility_connectListener' arg'1' arg'2' arg'3')
data ListenerQWindowVisibilityConst =
ListenerQWindowVisibilityConst (HoppyF.Ptr ListenerQWindowVisibilityConst)
| ListenerQWindowVisibilityConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQWindowVisibilityConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQWindowVisibilityConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQWindowVisibilityConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQWindowVisibilityToConst :: ListenerQWindowVisibility -> ListenerQWindowVisibilityConst
castListenerQWindowVisibilityToConst (ListenerQWindowVisibility ptr') = ListenerQWindowVisibilityConst $ HoppyF.castPtr ptr'
castListenerQWindowVisibilityToConst (ListenerQWindowVisibilityGc fptr' ptr') = ListenerQWindowVisibilityConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQWindowVisibilityConst where
nullptr = ListenerQWindowVisibilityConst HoppyF.nullPtr
withCppPtr (ListenerQWindowVisibilityConst ptr') f' = f' ptr'
withCppPtr (ListenerQWindowVisibilityConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQWindowVisibilityConst ptr') = ptr'
toPtr (ListenerQWindowVisibilityConstGc _ ptr') = ptr'
touchCppPtr (ListenerQWindowVisibilityConst _) = HoppyP.return ()
touchCppPtr (ListenerQWindowVisibilityConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQWindowVisibilityConst where
delete (ListenerQWindowVisibilityConst ptr') = delete'ListenerQWindowVisibility ptr'
delete (ListenerQWindowVisibilityConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQWindowVisibilityConst", " object."]
toGc this'@(ListenerQWindowVisibilityConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQWindowVisibilityConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQWindowVisibility :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQWindowVisibilityConstGc {}) = HoppyP.return this'
instance ListenerQWindowVisibilityConstPtr ListenerQWindowVisibilityConst where
toListenerQWindowVisibilityConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQWindowVisibilityConst where
toQObjectConst (ListenerQWindowVisibilityConst ptr') = M34.QObjectConst $ castListenerQWindowVisibilityToQObject ptr'
toQObjectConst (ListenerQWindowVisibilityConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQWindowVisibilityToQObject ptr'
data ListenerQWindowVisibility =
ListenerQWindowVisibility (HoppyF.Ptr ListenerQWindowVisibility)
| ListenerQWindowVisibilityGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQWindowVisibility)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQWindowVisibility where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQWindowVisibility where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQWindowVisibilityToNonconst :: ListenerQWindowVisibilityConst -> ListenerQWindowVisibility
castListenerQWindowVisibilityToNonconst (ListenerQWindowVisibilityConst ptr') = ListenerQWindowVisibility $ HoppyF.castPtr ptr'
castListenerQWindowVisibilityToNonconst (ListenerQWindowVisibilityConstGc fptr' ptr') = ListenerQWindowVisibilityGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQWindowVisibility where
nullptr = ListenerQWindowVisibility HoppyF.nullPtr
withCppPtr (ListenerQWindowVisibility ptr') f' = f' ptr'
withCppPtr (ListenerQWindowVisibilityGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQWindowVisibility ptr') = ptr'
toPtr (ListenerQWindowVisibilityGc _ ptr') = ptr'
touchCppPtr (ListenerQWindowVisibility _) = HoppyP.return ()
touchCppPtr (ListenerQWindowVisibilityGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQWindowVisibility where
delete (ListenerQWindowVisibility ptr') = delete'ListenerQWindowVisibility $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQWindowVisibilityConst)
delete (ListenerQWindowVisibilityGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQWindowVisibility", " object."]
toGc this'@(ListenerQWindowVisibility ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQWindowVisibilityGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQWindowVisibility :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQWindowVisibilityGc {}) = HoppyP.return this'
instance ListenerQWindowVisibilityConstPtr ListenerQWindowVisibility where
toListenerQWindowVisibilityConst (ListenerQWindowVisibility ptr') = ListenerQWindowVisibilityConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
toListenerQWindowVisibilityConst (ListenerQWindowVisibilityGc fptr' ptr') = ListenerQWindowVisibilityConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
instance ListenerQWindowVisibilityPtr ListenerQWindowVisibility where
toListenerQWindowVisibility = HoppyP.id
instance M34.QObjectConstPtr ListenerQWindowVisibility where
toQObjectConst (ListenerQWindowVisibility ptr') = M34.QObjectConst $ castListenerQWindowVisibilityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
toQObjectConst (ListenerQWindowVisibilityGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQWindowVisibilityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
instance M34.QObjectPtr ListenerQWindowVisibility where
toQObject (ListenerQWindowVisibility ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQWindowVisibilityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
toQObject (ListenerQWindowVisibilityGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQWindowVisibilityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQWindowVisibility -> HoppyF.Ptr ListenerQWindowVisibilityConst) ptr'
listenerQWindowVisibility_new :: (M176.QWindowVisibility -> HoppyP.IO ()) -> HoppyP.IO ListenerQWindowVisibility
listenerQWindowVisibility_new arg'1 =
M182.callbackQWindowVisibilityVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQWindowVisibility
(listenerQWindowVisibility_new' arg'1')
listenerQWindowVisibility_newWithParent :: (M34.QObjectPtr arg'2) => (M176.QWindowVisibility -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQWindowVisibility
listenerQWindowVisibility_newWithParent arg'1 arg'2 =
M182.callbackQWindowVisibilityVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQWindowVisibility
(listenerQWindowVisibility_newWithParent' arg'1' arg'2')
class ListenerQWindowVisibilitySuper a where
downToListenerQWindowVisibility :: a -> ListenerQWindowVisibility
instance ListenerQWindowVisibilitySuper M34.QObject where
downToListenerQWindowVisibility = castListenerQWindowVisibilityToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQWindowVisibilityConst $ castQObjectToListenerQWindowVisibility ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQWindowVisibilityConstGc fptr' $ castQObjectToListenerQWindowVisibility ptr'
class ListenerQWindowVisibilitySuperConst a where
downToListenerQWindowVisibilityConst :: a -> ListenerQWindowVisibilityConst
instance ListenerQWindowVisibilitySuperConst M34.QObjectConst where
downToListenerQWindowVisibilityConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQWindowVisibilityConst $ castQObjectToListenerQWindowVisibility ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQWindowVisibilityConstGc fptr' $ castQObjectToListenerQWindowVisibility ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQWindowVisibility)) ListenerQWindowVisibility where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQWindowVisibility)) ListenerQWindowVisibility where
decode = HoppyP.fmap ListenerQWindowVisibility . HoppyF.peek
class ListenerQrealValue a where
withListenerQrealPtr :: a -> (ListenerQrealConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerQrealConstPtr a => ListenerQrealValue a where
withListenerQrealPtr = HoppyP.flip ($) . toListenerQrealConst
class (M34.QObjectConstPtr this) => ListenerQrealConstPtr this where
toListenerQrealConst :: this -> ListenerQrealConst
class (ListenerQrealConstPtr this, M34.QObjectPtr this) => ListenerQrealPtr this where
toListenerQreal :: this -> ListenerQreal
listenerQreal_connectListener :: (ListenerQrealPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerQreal_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerQreal arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerQreal_connectListener' arg'1' arg'2' arg'3')
data ListenerQrealConst =
ListenerQrealConst (HoppyF.Ptr ListenerQrealConst)
| ListenerQrealConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQrealConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQrealConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQrealConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQrealToConst :: ListenerQreal -> ListenerQrealConst
castListenerQrealToConst (ListenerQreal ptr') = ListenerQrealConst $ HoppyF.castPtr ptr'
castListenerQrealToConst (ListenerQrealGc fptr' ptr') = ListenerQrealConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQrealConst where
nullptr = ListenerQrealConst HoppyF.nullPtr
withCppPtr (ListenerQrealConst ptr') f' = f' ptr'
withCppPtr (ListenerQrealConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQrealConst ptr') = ptr'
toPtr (ListenerQrealConstGc _ ptr') = ptr'
touchCppPtr (ListenerQrealConst _) = HoppyP.return ()
touchCppPtr (ListenerQrealConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQrealConst where
delete (ListenerQrealConst ptr') = delete'ListenerQreal ptr'
delete (ListenerQrealConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQrealConst", " object."]
toGc this'@(ListenerQrealConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQrealConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQreal :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQrealConstGc {}) = HoppyP.return this'
instance ListenerQrealConstPtr ListenerQrealConst where
toListenerQrealConst = HoppyP.id
instance M34.QObjectConstPtr ListenerQrealConst where
toQObjectConst (ListenerQrealConst ptr') = M34.QObjectConst $ castListenerQrealToQObject ptr'
toQObjectConst (ListenerQrealConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQrealToQObject ptr'
data ListenerQreal =
ListenerQreal (HoppyF.Ptr ListenerQreal)
| ListenerQrealGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerQreal)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerQreal where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerQreal where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerQrealToNonconst :: ListenerQrealConst -> ListenerQreal
castListenerQrealToNonconst (ListenerQrealConst ptr') = ListenerQreal $ HoppyF.castPtr ptr'
castListenerQrealToNonconst (ListenerQrealConstGc fptr' ptr') = ListenerQrealGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerQreal where
nullptr = ListenerQreal HoppyF.nullPtr
withCppPtr (ListenerQreal ptr') f' = f' ptr'
withCppPtr (ListenerQrealGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerQreal ptr') = ptr'
toPtr (ListenerQrealGc _ ptr') = ptr'
touchCppPtr (ListenerQreal _) = HoppyP.return ()
touchCppPtr (ListenerQrealGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerQreal where
delete (ListenerQreal ptr') = delete'ListenerQreal $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerQrealConst)
delete (ListenerQrealGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerQreal", " object."]
toGc this'@(ListenerQreal ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerQrealGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerQreal :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerQrealGc {}) = HoppyP.return this'
instance ListenerQrealConstPtr ListenerQreal where
toListenerQrealConst (ListenerQreal ptr') = ListenerQrealConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
toListenerQrealConst (ListenerQrealGc fptr' ptr') = ListenerQrealConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
instance ListenerQrealPtr ListenerQreal where
toListenerQreal = HoppyP.id
instance M34.QObjectConstPtr ListenerQreal where
toQObjectConst (ListenerQreal ptr') = M34.QObjectConst $ castListenerQrealToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
toQObjectConst (ListenerQrealGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerQrealToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
instance M34.QObjectPtr ListenerQreal where
toQObject (ListenerQreal ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQrealToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
toQObject (ListenerQrealGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerQrealToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerQreal -> HoppyF.Ptr ListenerQrealConst) ptr'
listenerQreal_new :: (HoppyP.Double -> HoppyP.IO ()) -> HoppyP.IO ListenerQreal
listenerQreal_new arg'1 =
M182.callbackQrealVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerQreal
(listenerQreal_new' arg'1')
listenerQreal_newWithParent :: (M34.QObjectPtr arg'2) => (HoppyP.Double -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerQreal
listenerQreal_newWithParent arg'1 arg'2 =
M182.callbackQrealVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerQreal
(listenerQreal_newWithParent' arg'1' arg'2')
class ListenerQrealSuper a where
downToListenerQreal :: a -> ListenerQreal
instance ListenerQrealSuper M34.QObject where
downToListenerQreal = castListenerQrealToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerQrealConst $ castQObjectToListenerQreal ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQrealConstGc fptr' $ castQObjectToListenerQreal ptr'
class ListenerQrealSuperConst a where
downToListenerQrealConst :: a -> ListenerQrealConst
instance ListenerQrealSuperConst M34.QObjectConst where
downToListenerQrealConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerQrealConst $ castQObjectToListenerQreal ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerQrealConstGc fptr' $ castQObjectToListenerQreal ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerQreal)) ListenerQreal where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerQreal)) ListenerQreal where
decode = HoppyP.fmap ListenerQreal . HoppyF.peek
class ListenerRefConstQIconValue a where
withListenerRefConstQIconPtr :: a -> (ListenerRefConstQIconConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerRefConstQIconConstPtr a => ListenerRefConstQIconValue a where
withListenerRefConstQIconPtr = HoppyP.flip ($) . toListenerRefConstQIconConst
class (M34.QObjectConstPtr this) => ListenerRefConstQIconConstPtr this where
toListenerRefConstQIconConst :: this -> ListenerRefConstQIconConst
class (ListenerRefConstQIconConstPtr this, M34.QObjectPtr this) => ListenerRefConstQIconPtr this where
toListenerRefConstQIcon :: this -> ListenerRefConstQIcon
listenerRefConstQIcon_connectListener :: (ListenerRefConstQIconPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerRefConstQIcon_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerRefConstQIcon arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerRefConstQIcon_connectListener' arg'1' arg'2' arg'3')
data ListenerRefConstQIconConst =
ListenerRefConstQIconConst (HoppyF.Ptr ListenerRefConstQIconConst)
| ListenerRefConstQIconConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerRefConstQIconConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerRefConstQIconConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerRefConstQIconConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerRefConstQIconToConst :: ListenerRefConstQIcon -> ListenerRefConstQIconConst
castListenerRefConstQIconToConst (ListenerRefConstQIcon ptr') = ListenerRefConstQIconConst $ HoppyF.castPtr ptr'
castListenerRefConstQIconToConst (ListenerRefConstQIconGc fptr' ptr') = ListenerRefConstQIconConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerRefConstQIconConst where
nullptr = ListenerRefConstQIconConst HoppyF.nullPtr
withCppPtr (ListenerRefConstQIconConst ptr') f' = f' ptr'
withCppPtr (ListenerRefConstQIconConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerRefConstQIconConst ptr') = ptr'
toPtr (ListenerRefConstQIconConstGc _ ptr') = ptr'
touchCppPtr (ListenerRefConstQIconConst _) = HoppyP.return ()
touchCppPtr (ListenerRefConstQIconConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerRefConstQIconConst where
delete (ListenerRefConstQIconConst ptr') = delete'ListenerRefConstQIcon ptr'
delete (ListenerRefConstQIconConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerRefConstQIconConst", " object."]
toGc this'@(ListenerRefConstQIconConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerRefConstQIconConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerRefConstQIcon :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerRefConstQIconConstGc {}) = HoppyP.return this'
instance ListenerRefConstQIconConstPtr ListenerRefConstQIconConst where
toListenerRefConstQIconConst = HoppyP.id
instance M34.QObjectConstPtr ListenerRefConstQIconConst where
toQObjectConst (ListenerRefConstQIconConst ptr') = M34.QObjectConst $ castListenerRefConstQIconToQObject ptr'
toQObjectConst (ListenerRefConstQIconConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerRefConstQIconToQObject ptr'
data ListenerRefConstQIcon =
ListenerRefConstQIcon (HoppyF.Ptr ListenerRefConstQIcon)
| ListenerRefConstQIconGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerRefConstQIcon)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerRefConstQIcon where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerRefConstQIcon where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerRefConstQIconToNonconst :: ListenerRefConstQIconConst -> ListenerRefConstQIcon
castListenerRefConstQIconToNonconst (ListenerRefConstQIconConst ptr') = ListenerRefConstQIcon $ HoppyF.castPtr ptr'
castListenerRefConstQIconToNonconst (ListenerRefConstQIconConstGc fptr' ptr') = ListenerRefConstQIconGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerRefConstQIcon where
nullptr = ListenerRefConstQIcon HoppyF.nullPtr
withCppPtr (ListenerRefConstQIcon ptr') f' = f' ptr'
withCppPtr (ListenerRefConstQIconGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerRefConstQIcon ptr') = ptr'
toPtr (ListenerRefConstQIconGc _ ptr') = ptr'
touchCppPtr (ListenerRefConstQIcon _) = HoppyP.return ()
touchCppPtr (ListenerRefConstQIconGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerRefConstQIcon where
delete (ListenerRefConstQIcon ptr') = delete'ListenerRefConstQIcon $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerRefConstQIconConst)
delete (ListenerRefConstQIconGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerRefConstQIcon", " object."]
toGc this'@(ListenerRefConstQIcon ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerRefConstQIconGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerRefConstQIcon :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerRefConstQIconGc {}) = HoppyP.return this'
instance ListenerRefConstQIconConstPtr ListenerRefConstQIcon where
toListenerRefConstQIconConst (ListenerRefConstQIcon ptr') = ListenerRefConstQIconConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
toListenerRefConstQIconConst (ListenerRefConstQIconGc fptr' ptr') = ListenerRefConstQIconConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
instance ListenerRefConstQIconPtr ListenerRefConstQIcon where
toListenerRefConstQIcon = HoppyP.id
instance M34.QObjectConstPtr ListenerRefConstQIcon where
toQObjectConst (ListenerRefConstQIcon ptr') = M34.QObjectConst $ castListenerRefConstQIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
toQObjectConst (ListenerRefConstQIconGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerRefConstQIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
instance M34.QObjectPtr ListenerRefConstQIcon where
toQObject (ListenerRefConstQIcon ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerRefConstQIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
toQObject (ListenerRefConstQIconGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerRefConstQIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQIcon -> HoppyF.Ptr ListenerRefConstQIconConst) ptr'
listenerRefConstQIcon_new :: (M124.QIconConst -> HoppyP.IO ()) -> HoppyP.IO ListenerRefConstQIcon
listenerRefConstQIcon_new arg'1 =
M182.callbackRefConstQIconVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerRefConstQIcon
(listenerRefConstQIcon_new' arg'1')
listenerRefConstQIcon_newWithParent :: (M34.QObjectPtr arg'2) => (M124.QIconConst -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerRefConstQIcon
listenerRefConstQIcon_newWithParent arg'1 arg'2 =
M182.callbackRefConstQIconVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerRefConstQIcon
(listenerRefConstQIcon_newWithParent' arg'1' arg'2')
class ListenerRefConstQIconSuper a where
downToListenerRefConstQIcon :: a -> ListenerRefConstQIcon
instance ListenerRefConstQIconSuper M34.QObject where
downToListenerRefConstQIcon = castListenerRefConstQIconToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerRefConstQIconConst $ castQObjectToListenerRefConstQIcon ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerRefConstQIconConstGc fptr' $ castQObjectToListenerRefConstQIcon ptr'
class ListenerRefConstQIconSuperConst a where
downToListenerRefConstQIconConst :: a -> ListenerRefConstQIconConst
instance ListenerRefConstQIconSuperConst M34.QObjectConst where
downToListenerRefConstQIconConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerRefConstQIconConst $ castQObjectToListenerRefConstQIcon ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerRefConstQIconConstGc fptr' $ castQObjectToListenerRefConstQIcon ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerRefConstQIcon)) ListenerRefConstQIcon where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerRefConstQIcon)) ListenerRefConstQIcon where
decode = HoppyP.fmap ListenerRefConstQIcon . HoppyF.peek
class ListenerRefConstQItemSelectionRefConstQItemSelectionValue a where
withListenerRefConstQItemSelectionRefConstQItemSelectionPtr :: a -> (ListenerRefConstQItemSelectionRefConstQItemSelectionConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr a => ListenerRefConstQItemSelectionRefConstQItemSelectionValue a where
withListenerRefConstQItemSelectionRefConstQItemSelectionPtr = HoppyP.flip ($) . toListenerRefConstQItemSelectionRefConstQItemSelectionConst
class (M34.QObjectConstPtr this) => ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr this where
toListenerRefConstQItemSelectionRefConstQItemSelectionConst :: this -> ListenerRefConstQItemSelectionRefConstQItemSelectionConst
class (ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr this, M34.QObjectPtr this) => ListenerRefConstQItemSelectionRefConstQItemSelectionPtr this where
toListenerRefConstQItemSelectionRefConstQItemSelection :: this -> ListenerRefConstQItemSelectionRefConstQItemSelection
listenerRefConstQItemSelectionRefConstQItemSelection_connectListener :: (ListenerRefConstQItemSelectionRefConstQItemSelectionPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerRefConstQItemSelectionRefConstQItemSelection_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerRefConstQItemSelectionRefConstQItemSelection arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerRefConstQItemSelectionRefConstQItemSelection_connectListener' arg'1' arg'2' arg'3')
data ListenerRefConstQItemSelectionRefConstQItemSelectionConst =
ListenerRefConstQItemSelectionRefConstQItemSelectionConst (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst)
| ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerRefConstQItemSelectionRefConstQItemSelectionToConst :: ListenerRefConstQItemSelectionRefConstQItemSelection -> ListenerRefConstQItemSelectionRefConstQItemSelectionConst
castListenerRefConstQItemSelectionRefConstQItemSelectionToConst (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConst $ HoppyF.castPtr ptr'
castListenerRefConstQItemSelectionRefConstQItemSelectionToConst (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
nullptr = ListenerRefConstQItemSelectionRefConstQItemSelectionConst HoppyF.nullPtr
withCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') f' = f' ptr'
withCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') = ptr'
toPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc _ ptr') = ptr'
touchCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConst _) = HoppyP.return ()
touchCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
delete (ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') = delete'ListenerRefConstQItemSelectionRefConstQItemSelection ptr'
delete (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerRefConstQItemSelectionRefConstQItemSelectionConst", " object."]
toGc this'@(ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerRefConstQItemSelectionRefConstQItemSelection :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc {}) = HoppyP.return this'
instance ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
toListenerRefConstQItemSelectionRefConstQItemSelectionConst = HoppyP.id
instance M34.QObjectConstPtr ListenerRefConstQItemSelectionRefConstQItemSelectionConst where
toQObjectConst (ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') = M34.QObjectConst $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject ptr'
toQObjectConst (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject ptr'
data ListenerRefConstQItemSelectionRefConstQItemSelection =
ListenerRefConstQItemSelectionRefConstQItemSelection (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)
| ListenerRefConstQItemSelectionRefConstQItemSelectionGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerRefConstQItemSelectionRefConstQItemSelection where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerRefConstQItemSelectionRefConstQItemSelection where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerRefConstQItemSelectionRefConstQItemSelectionToNonconst :: ListenerRefConstQItemSelectionRefConstQItemSelectionConst -> ListenerRefConstQItemSelectionRefConstQItemSelection
castListenerRefConstQItemSelectionRefConstQItemSelectionToNonconst (ListenerRefConstQItemSelectionRefConstQItemSelectionConst ptr') = ListenerRefConstQItemSelectionRefConstQItemSelection $ HoppyF.castPtr ptr'
castListenerRefConstQItemSelectionRefConstQItemSelectionToNonconst (ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerRefConstQItemSelectionRefConstQItemSelection where
nullptr = ListenerRefConstQItemSelectionRefConstQItemSelection HoppyF.nullPtr
withCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') f' = f' ptr'
withCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = ptr'
toPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionGc _ ptr') = ptr'
touchCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelection _) = HoppyP.return ()
touchCppPtr (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerRefConstQItemSelectionRefConstQItemSelection where
delete (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = delete'ListenerRefConstQItemSelectionRefConstQItemSelection $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst)
delete (ListenerRefConstQItemSelectionRefConstQItemSelectionGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerRefConstQItemSelectionRefConstQItemSelection", " object."]
toGc this'@(ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerRefConstQItemSelectionRefConstQItemSelectionGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerRefConstQItemSelectionRefConstQItemSelection :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerRefConstQItemSelectionRefConstQItemSelectionGc {}) = HoppyP.return this'
instance ListenerRefConstQItemSelectionRefConstQItemSelectionConstPtr ListenerRefConstQItemSelectionRefConstQItemSelection where
toListenerRefConstQItemSelectionRefConstQItemSelectionConst (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
toListenerRefConstQItemSelectionRefConstQItemSelectionConst (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
instance ListenerRefConstQItemSelectionRefConstQItemSelectionPtr ListenerRefConstQItemSelectionRefConstQItemSelection where
toListenerRefConstQItemSelectionRefConstQItemSelection = HoppyP.id
instance M34.QObjectConstPtr ListenerRefConstQItemSelectionRefConstQItemSelection where
toQObjectConst (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = M34.QObjectConst $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
toQObjectConst (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
instance M34.QObjectPtr ListenerRefConstQItemSelectionRefConstQItemSelection where
toQObject (ListenerRefConstQItemSelectionRefConstQItemSelection ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
toQObject (ListenerRefConstQItemSelectionRefConstQItemSelectionGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerRefConstQItemSelectionRefConstQItemSelectionToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection -> HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelectionConst) ptr'
listenerRefConstQItemSelectionRefConstQItemSelection_new :: (M22.QItemSelectionConst -> M22.QItemSelectionConst -> HoppyP.IO ()) -> HoppyP.IO ListenerRefConstQItemSelectionRefConstQItemSelection
listenerRefConstQItemSelectionRefConstQItemSelection_new arg'1 =
M182.callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerRefConstQItemSelectionRefConstQItemSelection
(listenerRefConstQItemSelectionRefConstQItemSelection_new' arg'1')
listenerRefConstQItemSelectionRefConstQItemSelection_newWithParent :: (M34.QObjectPtr arg'2) => (M22.QItemSelectionConst -> M22.QItemSelectionConst -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerRefConstQItemSelectionRefConstQItemSelection
listenerRefConstQItemSelectionRefConstQItemSelection_newWithParent arg'1 arg'2 =
M182.callbackRefConstQItemSelectionRefConstQItemSelectionVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerRefConstQItemSelectionRefConstQItemSelection
(listenerRefConstQItemSelectionRefConstQItemSelection_newWithParent' arg'1' arg'2')
class ListenerRefConstQItemSelectionRefConstQItemSelectionSuper a where
downToListenerRefConstQItemSelectionRefConstQItemSelection :: a -> ListenerRefConstQItemSelectionRefConstQItemSelection
instance ListenerRefConstQItemSelectionRefConstQItemSelectionSuper M34.QObject where
downToListenerRefConstQItemSelectionRefConstQItemSelection = castListenerRefConstQItemSelectionRefConstQItemSelectionToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConst $ castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' $ castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection ptr'
class ListenerRefConstQItemSelectionRefConstQItemSelectionSuperConst a where
downToListenerRefConstQItemSelectionRefConstQItemSelectionConst :: a -> ListenerRefConstQItemSelectionRefConstQItemSelectionConst
instance ListenerRefConstQItemSelectionRefConstQItemSelectionSuperConst M34.QObjectConst where
downToListenerRefConstQItemSelectionRefConstQItemSelectionConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConst $ castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerRefConstQItemSelectionRefConstQItemSelectionConstGc fptr' $ castQObjectToListenerRefConstQItemSelectionRefConstQItemSelection ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)) ListenerRefConstQItemSelectionRefConstQItemSelection where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerRefConstQItemSelectionRefConstQItemSelection)) ListenerRefConstQItemSelectionRefConstQItemSelection where
decode = HoppyP.fmap ListenerRefConstQItemSelectionRefConstQItemSelection . HoppyF.peek
class ListenerScreenOrientationValue a where
withListenerScreenOrientationPtr :: a -> (ListenerScreenOrientationConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerScreenOrientationConstPtr a => ListenerScreenOrientationValue a where
withListenerScreenOrientationPtr = HoppyP.flip ($) . toListenerScreenOrientationConst
class (M34.QObjectConstPtr this) => ListenerScreenOrientationConstPtr this where
toListenerScreenOrientationConst :: this -> ListenerScreenOrientationConst
class (ListenerScreenOrientationConstPtr this, M34.QObjectPtr this) => ListenerScreenOrientationPtr this where
toListenerScreenOrientation :: this -> ListenerScreenOrientation
listenerScreenOrientation_connectListener :: (ListenerScreenOrientationPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerScreenOrientation_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerScreenOrientation arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerScreenOrientation_connectListener' arg'1' arg'2' arg'3')
data ListenerScreenOrientationConst =
ListenerScreenOrientationConst (HoppyF.Ptr ListenerScreenOrientationConst)
| ListenerScreenOrientationConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerScreenOrientationConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerScreenOrientationConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerScreenOrientationConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerScreenOrientationToConst :: ListenerScreenOrientation -> ListenerScreenOrientationConst
castListenerScreenOrientationToConst (ListenerScreenOrientation ptr') = ListenerScreenOrientationConst $ HoppyF.castPtr ptr'
castListenerScreenOrientationToConst (ListenerScreenOrientationGc fptr' ptr') = ListenerScreenOrientationConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerScreenOrientationConst where
nullptr = ListenerScreenOrientationConst HoppyF.nullPtr
withCppPtr (ListenerScreenOrientationConst ptr') f' = f' ptr'
withCppPtr (ListenerScreenOrientationConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerScreenOrientationConst ptr') = ptr'
toPtr (ListenerScreenOrientationConstGc _ ptr') = ptr'
touchCppPtr (ListenerScreenOrientationConst _) = HoppyP.return ()
touchCppPtr (ListenerScreenOrientationConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerScreenOrientationConst where
delete (ListenerScreenOrientationConst ptr') = delete'ListenerScreenOrientation ptr'
delete (ListenerScreenOrientationConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerScreenOrientationConst", " object."]
toGc this'@(ListenerScreenOrientationConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerScreenOrientationConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerScreenOrientation :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerScreenOrientationConstGc {}) = HoppyP.return this'
instance ListenerScreenOrientationConstPtr ListenerScreenOrientationConst where
toListenerScreenOrientationConst = HoppyP.id
instance M34.QObjectConstPtr ListenerScreenOrientationConst where
toQObjectConst (ListenerScreenOrientationConst ptr') = M34.QObjectConst $ castListenerScreenOrientationToQObject ptr'
toQObjectConst (ListenerScreenOrientationConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerScreenOrientationToQObject ptr'
data ListenerScreenOrientation =
ListenerScreenOrientation (HoppyF.Ptr ListenerScreenOrientation)
| ListenerScreenOrientationGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerScreenOrientation)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerScreenOrientation where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerScreenOrientation where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerScreenOrientationToNonconst :: ListenerScreenOrientationConst -> ListenerScreenOrientation
castListenerScreenOrientationToNonconst (ListenerScreenOrientationConst ptr') = ListenerScreenOrientation $ HoppyF.castPtr ptr'
castListenerScreenOrientationToNonconst (ListenerScreenOrientationConstGc fptr' ptr') = ListenerScreenOrientationGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerScreenOrientation where
nullptr = ListenerScreenOrientation HoppyF.nullPtr
withCppPtr (ListenerScreenOrientation ptr') f' = f' ptr'
withCppPtr (ListenerScreenOrientationGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerScreenOrientation ptr') = ptr'
toPtr (ListenerScreenOrientationGc _ ptr') = ptr'
touchCppPtr (ListenerScreenOrientation _) = HoppyP.return ()
touchCppPtr (ListenerScreenOrientationGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerScreenOrientation where
delete (ListenerScreenOrientation ptr') = delete'ListenerScreenOrientation $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerScreenOrientationConst)
delete (ListenerScreenOrientationGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerScreenOrientation", " object."]
toGc this'@(ListenerScreenOrientation ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerScreenOrientationGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerScreenOrientation :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerScreenOrientationGc {}) = HoppyP.return this'
instance ListenerScreenOrientationConstPtr ListenerScreenOrientation where
toListenerScreenOrientationConst (ListenerScreenOrientation ptr') = ListenerScreenOrientationConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
toListenerScreenOrientationConst (ListenerScreenOrientationGc fptr' ptr') = ListenerScreenOrientationConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
instance ListenerScreenOrientationPtr ListenerScreenOrientation where
toListenerScreenOrientation = HoppyP.id
instance M34.QObjectConstPtr ListenerScreenOrientation where
toQObjectConst (ListenerScreenOrientation ptr') = M34.QObjectConst $ castListenerScreenOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
toQObjectConst (ListenerScreenOrientationGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerScreenOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
instance M34.QObjectPtr ListenerScreenOrientation where
toQObject (ListenerScreenOrientation ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerScreenOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
toQObject (ListenerScreenOrientationGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerScreenOrientationToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerScreenOrientation -> HoppyF.Ptr ListenerScreenOrientationConst) ptr'
listenerScreenOrientation_new :: (M68.QtScreenOrientation -> HoppyP.IO ()) -> HoppyP.IO ListenerScreenOrientation
listenerScreenOrientation_new arg'1 =
M182.callbackScreenOrientationVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerScreenOrientation
(listenerScreenOrientation_new' arg'1')
listenerScreenOrientation_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtScreenOrientation -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerScreenOrientation
listenerScreenOrientation_newWithParent arg'1 arg'2 =
M182.callbackScreenOrientationVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerScreenOrientation
(listenerScreenOrientation_newWithParent' arg'1' arg'2')
class ListenerScreenOrientationSuper a where
downToListenerScreenOrientation :: a -> ListenerScreenOrientation
instance ListenerScreenOrientationSuper M34.QObject where
downToListenerScreenOrientation = castListenerScreenOrientationToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerScreenOrientationConst $ castQObjectToListenerScreenOrientation ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerScreenOrientationConstGc fptr' $ castQObjectToListenerScreenOrientation ptr'
class ListenerScreenOrientationSuperConst a where
downToListenerScreenOrientationConst :: a -> ListenerScreenOrientationConst
instance ListenerScreenOrientationSuperConst M34.QObjectConst where
downToListenerScreenOrientationConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerScreenOrientationConst $ castQObjectToListenerScreenOrientation ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerScreenOrientationConstGc fptr' $ castQObjectToListenerScreenOrientation ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerScreenOrientation)) ListenerScreenOrientation where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerScreenOrientation)) ListenerScreenOrientation where
decode = HoppyP.fmap ListenerScreenOrientation . HoppyF.peek
class ListenerToolBarAreasValue a where
withListenerToolBarAreasPtr :: a -> (ListenerToolBarAreasConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerToolBarAreasConstPtr a => ListenerToolBarAreasValue a where
withListenerToolBarAreasPtr = HoppyP.flip ($) . toListenerToolBarAreasConst
class (M34.QObjectConstPtr this) => ListenerToolBarAreasConstPtr this where
toListenerToolBarAreasConst :: this -> ListenerToolBarAreasConst
class (ListenerToolBarAreasConstPtr this, M34.QObjectPtr this) => ListenerToolBarAreasPtr this where
toListenerToolBarAreas :: this -> ListenerToolBarAreas
listenerToolBarAreas_connectListener :: (ListenerToolBarAreasPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerToolBarAreas_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerToolBarAreas arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerToolBarAreas_connectListener' arg'1' arg'2' arg'3')
data ListenerToolBarAreasConst =
ListenerToolBarAreasConst (HoppyF.Ptr ListenerToolBarAreasConst)
| ListenerToolBarAreasConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerToolBarAreasConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerToolBarAreasConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerToolBarAreasConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToolBarAreasToConst :: ListenerToolBarAreas -> ListenerToolBarAreasConst
castListenerToolBarAreasToConst (ListenerToolBarAreas ptr') = ListenerToolBarAreasConst $ HoppyF.castPtr ptr'
castListenerToolBarAreasToConst (ListenerToolBarAreasGc fptr' ptr') = ListenerToolBarAreasConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerToolBarAreasConst where
nullptr = ListenerToolBarAreasConst HoppyF.nullPtr
withCppPtr (ListenerToolBarAreasConst ptr') f' = f' ptr'
withCppPtr (ListenerToolBarAreasConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerToolBarAreasConst ptr') = ptr'
toPtr (ListenerToolBarAreasConstGc _ ptr') = ptr'
touchCppPtr (ListenerToolBarAreasConst _) = HoppyP.return ()
touchCppPtr (ListenerToolBarAreasConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerToolBarAreasConst where
delete (ListenerToolBarAreasConst ptr') = delete'ListenerToolBarAreas ptr'
delete (ListenerToolBarAreasConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerToolBarAreasConst", " object."]
toGc this'@(ListenerToolBarAreasConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerToolBarAreasConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerToolBarAreas :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerToolBarAreasConstGc {}) = HoppyP.return this'
instance ListenerToolBarAreasConstPtr ListenerToolBarAreasConst where
toListenerToolBarAreasConst = HoppyP.id
instance M34.QObjectConstPtr ListenerToolBarAreasConst where
toQObjectConst (ListenerToolBarAreasConst ptr') = M34.QObjectConst $ castListenerToolBarAreasToQObject ptr'
toQObjectConst (ListenerToolBarAreasConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToolBarAreasToQObject ptr'
data ListenerToolBarAreas =
ListenerToolBarAreas (HoppyF.Ptr ListenerToolBarAreas)
| ListenerToolBarAreasGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerToolBarAreas)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerToolBarAreas where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerToolBarAreas where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToolBarAreasToNonconst :: ListenerToolBarAreasConst -> ListenerToolBarAreas
castListenerToolBarAreasToNonconst (ListenerToolBarAreasConst ptr') = ListenerToolBarAreas $ HoppyF.castPtr ptr'
castListenerToolBarAreasToNonconst (ListenerToolBarAreasConstGc fptr' ptr') = ListenerToolBarAreasGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerToolBarAreas where
nullptr = ListenerToolBarAreas HoppyF.nullPtr
withCppPtr (ListenerToolBarAreas ptr') f' = f' ptr'
withCppPtr (ListenerToolBarAreasGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerToolBarAreas ptr') = ptr'
toPtr (ListenerToolBarAreasGc _ ptr') = ptr'
touchCppPtr (ListenerToolBarAreas _) = HoppyP.return ()
touchCppPtr (ListenerToolBarAreasGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerToolBarAreas where
delete (ListenerToolBarAreas ptr') = delete'ListenerToolBarAreas $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerToolBarAreasConst)
delete (ListenerToolBarAreasGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerToolBarAreas", " object."]
toGc this'@(ListenerToolBarAreas ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerToolBarAreasGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerToolBarAreas :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerToolBarAreasGc {}) = HoppyP.return this'
instance ListenerToolBarAreasConstPtr ListenerToolBarAreas where
toListenerToolBarAreasConst (ListenerToolBarAreas ptr') = ListenerToolBarAreasConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
toListenerToolBarAreasConst (ListenerToolBarAreasGc fptr' ptr') = ListenerToolBarAreasConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
instance ListenerToolBarAreasPtr ListenerToolBarAreas where
toListenerToolBarAreas = HoppyP.id
instance M34.QObjectConstPtr ListenerToolBarAreas where
toQObjectConst (ListenerToolBarAreas ptr') = M34.QObjectConst $ castListenerToolBarAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
toQObjectConst (ListenerToolBarAreasGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToolBarAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
instance M34.QObjectPtr ListenerToolBarAreas where
toQObject (ListenerToolBarAreas ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToolBarAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
toQObject (ListenerToolBarAreasGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToolBarAreasToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolBarAreas -> HoppyF.Ptr ListenerToolBarAreasConst) ptr'
listenerToolBarAreas_new :: (M68.QtToolBarAreas -> HoppyP.IO ()) -> HoppyP.IO ListenerToolBarAreas
listenerToolBarAreas_new arg'1 =
M182.callbackToolBarAreasVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerToolBarAreas
(listenerToolBarAreas_new' arg'1')
listenerToolBarAreas_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtToolBarAreas -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerToolBarAreas
listenerToolBarAreas_newWithParent arg'1 arg'2 =
M182.callbackToolBarAreasVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerToolBarAreas
(listenerToolBarAreas_newWithParent' arg'1' arg'2')
class ListenerToolBarAreasSuper a where
downToListenerToolBarAreas :: a -> ListenerToolBarAreas
instance ListenerToolBarAreasSuper M34.QObject where
downToListenerToolBarAreas = castListenerToolBarAreasToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerToolBarAreasConst $ castQObjectToListenerToolBarAreas ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerToolBarAreasConstGc fptr' $ castQObjectToListenerToolBarAreas ptr'
class ListenerToolBarAreasSuperConst a where
downToListenerToolBarAreasConst :: a -> ListenerToolBarAreasConst
instance ListenerToolBarAreasSuperConst M34.QObjectConst where
downToListenerToolBarAreasConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerToolBarAreasConst $ castQObjectToListenerToolBarAreas ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerToolBarAreasConstGc fptr' $ castQObjectToListenerToolBarAreas ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerToolBarAreas)) ListenerToolBarAreas where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerToolBarAreas)) ListenerToolBarAreas where
decode = HoppyP.fmap ListenerToolBarAreas . HoppyF.peek
class ListenerToolButtonStyleValue a where
withListenerToolButtonStylePtr :: a -> (ListenerToolButtonStyleConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerToolButtonStyleConstPtr a => ListenerToolButtonStyleValue a where
withListenerToolButtonStylePtr = HoppyP.flip ($) . toListenerToolButtonStyleConst
class (M34.QObjectConstPtr this) => ListenerToolButtonStyleConstPtr this where
toListenerToolButtonStyleConst :: this -> ListenerToolButtonStyleConst
class (ListenerToolButtonStyleConstPtr this, M34.QObjectPtr this) => ListenerToolButtonStylePtr this where
toListenerToolButtonStyle :: this -> ListenerToolButtonStyle
listenerToolButtonStyle_connectListener :: (ListenerToolButtonStylePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerToolButtonStyle_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerToolButtonStyle arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerToolButtonStyle_connectListener' arg'1' arg'2' arg'3')
data ListenerToolButtonStyleConst =
ListenerToolButtonStyleConst (HoppyF.Ptr ListenerToolButtonStyleConst)
| ListenerToolButtonStyleConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerToolButtonStyleConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerToolButtonStyleConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerToolButtonStyleConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToolButtonStyleToConst :: ListenerToolButtonStyle -> ListenerToolButtonStyleConst
castListenerToolButtonStyleToConst (ListenerToolButtonStyle ptr') = ListenerToolButtonStyleConst $ HoppyF.castPtr ptr'
castListenerToolButtonStyleToConst (ListenerToolButtonStyleGc fptr' ptr') = ListenerToolButtonStyleConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerToolButtonStyleConst where
nullptr = ListenerToolButtonStyleConst HoppyF.nullPtr
withCppPtr (ListenerToolButtonStyleConst ptr') f' = f' ptr'
withCppPtr (ListenerToolButtonStyleConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerToolButtonStyleConst ptr') = ptr'
toPtr (ListenerToolButtonStyleConstGc _ ptr') = ptr'
touchCppPtr (ListenerToolButtonStyleConst _) = HoppyP.return ()
touchCppPtr (ListenerToolButtonStyleConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerToolButtonStyleConst where
delete (ListenerToolButtonStyleConst ptr') = delete'ListenerToolButtonStyle ptr'
delete (ListenerToolButtonStyleConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerToolButtonStyleConst", " object."]
toGc this'@(ListenerToolButtonStyleConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerToolButtonStyleConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerToolButtonStyle :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerToolButtonStyleConstGc {}) = HoppyP.return this'
instance ListenerToolButtonStyleConstPtr ListenerToolButtonStyleConst where
toListenerToolButtonStyleConst = HoppyP.id
instance M34.QObjectConstPtr ListenerToolButtonStyleConst where
toQObjectConst (ListenerToolButtonStyleConst ptr') = M34.QObjectConst $ castListenerToolButtonStyleToQObject ptr'
toQObjectConst (ListenerToolButtonStyleConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToolButtonStyleToQObject ptr'
data ListenerToolButtonStyle =
ListenerToolButtonStyle (HoppyF.Ptr ListenerToolButtonStyle)
| ListenerToolButtonStyleGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerToolButtonStyle)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerToolButtonStyle where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerToolButtonStyle where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerToolButtonStyleToNonconst :: ListenerToolButtonStyleConst -> ListenerToolButtonStyle
castListenerToolButtonStyleToNonconst (ListenerToolButtonStyleConst ptr') = ListenerToolButtonStyle $ HoppyF.castPtr ptr'
castListenerToolButtonStyleToNonconst (ListenerToolButtonStyleConstGc fptr' ptr') = ListenerToolButtonStyleGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerToolButtonStyle where
nullptr = ListenerToolButtonStyle HoppyF.nullPtr
withCppPtr (ListenerToolButtonStyle ptr') f' = f' ptr'
withCppPtr (ListenerToolButtonStyleGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerToolButtonStyle ptr') = ptr'
toPtr (ListenerToolButtonStyleGc _ ptr') = ptr'
touchCppPtr (ListenerToolButtonStyle _) = HoppyP.return ()
touchCppPtr (ListenerToolButtonStyleGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerToolButtonStyle where
delete (ListenerToolButtonStyle ptr') = delete'ListenerToolButtonStyle $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerToolButtonStyleConst)
delete (ListenerToolButtonStyleGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerToolButtonStyle", " object."]
toGc this'@(ListenerToolButtonStyle ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerToolButtonStyleGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerToolButtonStyle :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerToolButtonStyleGc {}) = HoppyP.return this'
instance ListenerToolButtonStyleConstPtr ListenerToolButtonStyle where
toListenerToolButtonStyleConst (ListenerToolButtonStyle ptr') = ListenerToolButtonStyleConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
toListenerToolButtonStyleConst (ListenerToolButtonStyleGc fptr' ptr') = ListenerToolButtonStyleConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
instance ListenerToolButtonStylePtr ListenerToolButtonStyle where
toListenerToolButtonStyle = HoppyP.id
instance M34.QObjectConstPtr ListenerToolButtonStyle where
toQObjectConst (ListenerToolButtonStyle ptr') = M34.QObjectConst $ castListenerToolButtonStyleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
toQObjectConst (ListenerToolButtonStyleGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerToolButtonStyleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
instance M34.QObjectPtr ListenerToolButtonStyle where
toQObject (ListenerToolButtonStyle ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToolButtonStyleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
toQObject (ListenerToolButtonStyleGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerToolButtonStyleToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerToolButtonStyle -> HoppyF.Ptr ListenerToolButtonStyleConst) ptr'
listenerToolButtonStyle_new :: (M68.QtToolButtonStyle -> HoppyP.IO ()) -> HoppyP.IO ListenerToolButtonStyle
listenerToolButtonStyle_new arg'1 =
M182.callbackToolButtonStyleVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerToolButtonStyle
(listenerToolButtonStyle_new' arg'1')
listenerToolButtonStyle_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtToolButtonStyle -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerToolButtonStyle
listenerToolButtonStyle_newWithParent arg'1 arg'2 =
M182.callbackToolButtonStyleVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerToolButtonStyle
(listenerToolButtonStyle_newWithParent' arg'1' arg'2')
class ListenerToolButtonStyleSuper a where
downToListenerToolButtonStyle :: a -> ListenerToolButtonStyle
instance ListenerToolButtonStyleSuper M34.QObject where
downToListenerToolButtonStyle = castListenerToolButtonStyleToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerToolButtonStyleConst $ castQObjectToListenerToolButtonStyle ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerToolButtonStyleConstGc fptr' $ castQObjectToListenerToolButtonStyle ptr'
class ListenerToolButtonStyleSuperConst a where
downToListenerToolButtonStyleConst :: a -> ListenerToolButtonStyleConst
instance ListenerToolButtonStyleSuperConst M34.QObjectConst where
downToListenerToolButtonStyleConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerToolButtonStyleConst $ castQObjectToListenerToolButtonStyle ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerToolButtonStyleConstGc fptr' $ castQObjectToListenerToolButtonStyle ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerToolButtonStyle)) ListenerToolButtonStyle where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerToolButtonStyle)) ListenerToolButtonStyle where
decode = HoppyP.fmap ListenerToolButtonStyle . HoppyF.peek
class ListenerWindowModalityValue a where
withListenerWindowModalityPtr :: a -> (ListenerWindowModalityConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerWindowModalityConstPtr a => ListenerWindowModalityValue a where
withListenerWindowModalityPtr = HoppyP.flip ($) . toListenerWindowModalityConst
class (M34.QObjectConstPtr this) => ListenerWindowModalityConstPtr this where
toListenerWindowModalityConst :: this -> ListenerWindowModalityConst
class (ListenerWindowModalityConstPtr this, M34.QObjectPtr this) => ListenerWindowModalityPtr this where
toListenerWindowModality :: this -> ListenerWindowModality
listenerWindowModality_connectListener :: (ListenerWindowModalityPtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerWindowModality_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerWindowModality arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerWindowModality_connectListener' arg'1' arg'2' arg'3')
data ListenerWindowModalityConst =
ListenerWindowModalityConst (HoppyF.Ptr ListenerWindowModalityConst)
| ListenerWindowModalityConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerWindowModalityConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerWindowModalityConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerWindowModalityConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerWindowModalityToConst :: ListenerWindowModality -> ListenerWindowModalityConst
castListenerWindowModalityToConst (ListenerWindowModality ptr') = ListenerWindowModalityConst $ HoppyF.castPtr ptr'
castListenerWindowModalityToConst (ListenerWindowModalityGc fptr' ptr') = ListenerWindowModalityConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerWindowModalityConst where
nullptr = ListenerWindowModalityConst HoppyF.nullPtr
withCppPtr (ListenerWindowModalityConst ptr') f' = f' ptr'
withCppPtr (ListenerWindowModalityConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerWindowModalityConst ptr') = ptr'
toPtr (ListenerWindowModalityConstGc _ ptr') = ptr'
touchCppPtr (ListenerWindowModalityConst _) = HoppyP.return ()
touchCppPtr (ListenerWindowModalityConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerWindowModalityConst where
delete (ListenerWindowModalityConst ptr') = delete'ListenerWindowModality ptr'
delete (ListenerWindowModalityConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerWindowModalityConst", " object."]
toGc this'@(ListenerWindowModalityConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerWindowModalityConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerWindowModality :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerWindowModalityConstGc {}) = HoppyP.return this'
instance ListenerWindowModalityConstPtr ListenerWindowModalityConst where
toListenerWindowModalityConst = HoppyP.id
instance M34.QObjectConstPtr ListenerWindowModalityConst where
toQObjectConst (ListenerWindowModalityConst ptr') = M34.QObjectConst $ castListenerWindowModalityToQObject ptr'
toQObjectConst (ListenerWindowModalityConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerWindowModalityToQObject ptr'
data ListenerWindowModality =
ListenerWindowModality (HoppyF.Ptr ListenerWindowModality)
| ListenerWindowModalityGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerWindowModality)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerWindowModality where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerWindowModality where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerWindowModalityToNonconst :: ListenerWindowModalityConst -> ListenerWindowModality
castListenerWindowModalityToNonconst (ListenerWindowModalityConst ptr') = ListenerWindowModality $ HoppyF.castPtr ptr'
castListenerWindowModalityToNonconst (ListenerWindowModalityConstGc fptr' ptr') = ListenerWindowModalityGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerWindowModality where
nullptr = ListenerWindowModality HoppyF.nullPtr
withCppPtr (ListenerWindowModality ptr') f' = f' ptr'
withCppPtr (ListenerWindowModalityGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerWindowModality ptr') = ptr'
toPtr (ListenerWindowModalityGc _ ptr') = ptr'
touchCppPtr (ListenerWindowModality _) = HoppyP.return ()
touchCppPtr (ListenerWindowModalityGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerWindowModality where
delete (ListenerWindowModality ptr') = delete'ListenerWindowModality $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerWindowModalityConst)
delete (ListenerWindowModalityGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerWindowModality", " object."]
toGc this'@(ListenerWindowModality ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerWindowModalityGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerWindowModality :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerWindowModalityGc {}) = HoppyP.return this'
instance ListenerWindowModalityConstPtr ListenerWindowModality where
toListenerWindowModalityConst (ListenerWindowModality ptr') = ListenerWindowModalityConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
toListenerWindowModalityConst (ListenerWindowModalityGc fptr' ptr') = ListenerWindowModalityConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
instance ListenerWindowModalityPtr ListenerWindowModality where
toListenerWindowModality = HoppyP.id
instance M34.QObjectConstPtr ListenerWindowModality where
toQObjectConst (ListenerWindowModality ptr') = M34.QObjectConst $ castListenerWindowModalityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
toQObjectConst (ListenerWindowModalityGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerWindowModalityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
instance M34.QObjectPtr ListenerWindowModality where
toQObject (ListenerWindowModality ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerWindowModalityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
toQObject (ListenerWindowModalityGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerWindowModalityToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowModality -> HoppyF.Ptr ListenerWindowModalityConst) ptr'
listenerWindowModality_new :: (M68.QtWindowModality -> HoppyP.IO ()) -> HoppyP.IO ListenerWindowModality
listenerWindowModality_new arg'1 =
M182.callbackWindowModalityVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerWindowModality
(listenerWindowModality_new' arg'1')
listenerWindowModality_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtWindowModality -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerWindowModality
listenerWindowModality_newWithParent arg'1 arg'2 =
M182.callbackWindowModalityVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerWindowModality
(listenerWindowModality_newWithParent' arg'1' arg'2')
class ListenerWindowModalitySuper a where
downToListenerWindowModality :: a -> ListenerWindowModality
instance ListenerWindowModalitySuper M34.QObject where
downToListenerWindowModality = castListenerWindowModalityToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerWindowModalityConst $ castQObjectToListenerWindowModality ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerWindowModalityConstGc fptr' $ castQObjectToListenerWindowModality ptr'
class ListenerWindowModalitySuperConst a where
downToListenerWindowModalityConst :: a -> ListenerWindowModalityConst
instance ListenerWindowModalitySuperConst M34.QObjectConst where
downToListenerWindowModalityConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerWindowModalityConst $ castQObjectToListenerWindowModality ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerWindowModalityConstGc fptr' $ castQObjectToListenerWindowModality ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerWindowModality)) ListenerWindowModality where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerWindowModality)) ListenerWindowModality where
decode = HoppyP.fmap ListenerWindowModality . HoppyF.peek
class ListenerWindowStateValue a where
withListenerWindowStatePtr :: a -> (ListenerWindowStateConst -> HoppyP.IO b) -> HoppyP.IO b
instance {-# OVERLAPPABLE #-} ListenerWindowStateConstPtr a => ListenerWindowStateValue a where
withListenerWindowStatePtr = HoppyP.flip ($) . toListenerWindowStateConst
class (M34.QObjectConstPtr this) => ListenerWindowStateConstPtr this where
toListenerWindowStateConst :: this -> ListenerWindowStateConst
class (ListenerWindowStateConstPtr this, M34.QObjectPtr this) => ListenerWindowStatePtr this where
toListenerWindowState :: this -> ListenerWindowState
listenerWindowState_connectListener :: (ListenerWindowStatePtr arg'1, M34.QObjectPtr arg'2, M1.StdStringValue arg'3) => arg'1 -> arg'2 -> arg'3 -> HoppyP.IO HoppyP.Bool
listenerWindowState_connectListener arg'1 arg'2 arg'3 =
HoppyFHR.withCppPtr (toListenerWindowState arg'1) $ \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
M1.withStdStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
HoppyP.fmap (/= 0)
(listenerWindowState_connectListener' arg'1' arg'2' arg'3')
data ListenerWindowStateConst =
ListenerWindowStateConst (HoppyF.Ptr ListenerWindowStateConst)
| ListenerWindowStateConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerWindowStateConst)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerWindowStateConst where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerWindowStateConst where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerWindowStateToConst :: ListenerWindowState -> ListenerWindowStateConst
castListenerWindowStateToConst (ListenerWindowState ptr') = ListenerWindowStateConst $ HoppyF.castPtr ptr'
castListenerWindowStateToConst (ListenerWindowStateGc fptr' ptr') = ListenerWindowStateConstGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerWindowStateConst where
nullptr = ListenerWindowStateConst HoppyF.nullPtr
withCppPtr (ListenerWindowStateConst ptr') f' = f' ptr'
withCppPtr (ListenerWindowStateConstGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerWindowStateConst ptr') = ptr'
toPtr (ListenerWindowStateConstGc _ ptr') = ptr'
touchCppPtr (ListenerWindowStateConst _) = HoppyP.return ()
touchCppPtr (ListenerWindowStateConstGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerWindowStateConst where
delete (ListenerWindowStateConst ptr') = delete'ListenerWindowState ptr'
delete (ListenerWindowStateConstGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerWindowStateConst", " object."]
toGc this'@(ListenerWindowStateConst ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerWindowStateConstGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerWindowState :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerWindowStateConstGc {}) = HoppyP.return this'
instance ListenerWindowStateConstPtr ListenerWindowStateConst where
toListenerWindowStateConst = HoppyP.id
instance M34.QObjectConstPtr ListenerWindowStateConst where
toQObjectConst (ListenerWindowStateConst ptr') = M34.QObjectConst $ castListenerWindowStateToQObject ptr'
toQObjectConst (ListenerWindowStateConstGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerWindowStateToQObject ptr'
data ListenerWindowState =
ListenerWindowState (HoppyF.Ptr ListenerWindowState)
| ListenerWindowStateGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr ListenerWindowState)
deriving (HoppyP.Show)
instance HoppyP.Eq ListenerWindowState where
x == y = HoppyFHR.toPtr x == HoppyFHR.toPtr y
instance HoppyP.Ord ListenerWindowState where
compare x y = HoppyP.compare (HoppyFHR.toPtr x) (HoppyFHR.toPtr y)
castListenerWindowStateToNonconst :: ListenerWindowStateConst -> ListenerWindowState
castListenerWindowStateToNonconst (ListenerWindowStateConst ptr') = ListenerWindowState $ HoppyF.castPtr ptr'
castListenerWindowStateToNonconst (ListenerWindowStateConstGc fptr' ptr') = ListenerWindowStateGc fptr' $ HoppyF.castPtr ptr'
instance HoppyFHR.CppPtr ListenerWindowState where
nullptr = ListenerWindowState HoppyF.nullPtr
withCppPtr (ListenerWindowState ptr') f' = f' ptr'
withCppPtr (ListenerWindowStateGc fptr' ptr') f' = HoppyF.withForeignPtr fptr' $ \_ -> f' ptr'
toPtr (ListenerWindowState ptr') = ptr'
toPtr (ListenerWindowStateGc _ ptr') = ptr'
touchCppPtr (ListenerWindowState _) = HoppyP.return ()
touchCppPtr (ListenerWindowStateGc fptr' _) = HoppyF.touchForeignPtr fptr'
instance HoppyFHR.Deletable ListenerWindowState where
delete (ListenerWindowState ptr') = delete'ListenerWindowState $ (HoppyF.castPtr ptr' :: HoppyF.Ptr ListenerWindowStateConst)
delete (ListenerWindowStateGc _ _) = HoppyP.fail $ HoppyP.concat ["Deletable.delete: Asked to delete a GC-managed ", "ListenerWindowState", " object."]
toGc this'@(ListenerWindowState ptr') = if ptr' == HoppyF.nullPtr then HoppyP.return this' else HoppyP.fmap (HoppyP.flip ListenerWindowStateGc ptr') $ HoppyF.newForeignPtr (HoppyF.castFunPtr deletePtr'ListenerWindowState :: HoppyF.FunPtr (HoppyF.Ptr () -> HoppyP.IO ())) (HoppyF.castPtr ptr' :: HoppyF.Ptr ())
toGc this'@(ListenerWindowStateGc {}) = HoppyP.return this'
instance ListenerWindowStateConstPtr ListenerWindowState where
toListenerWindowStateConst (ListenerWindowState ptr') = ListenerWindowStateConst $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
toListenerWindowStateConst (ListenerWindowStateGc fptr' ptr') = ListenerWindowStateConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
instance ListenerWindowStatePtr ListenerWindowState where
toListenerWindowState = HoppyP.id
instance M34.QObjectConstPtr ListenerWindowState where
toQObjectConst (ListenerWindowState ptr') = M34.QObjectConst $ castListenerWindowStateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
toQObjectConst (ListenerWindowStateGc fptr' ptr') = M34.QObjectConstGc fptr' $ castListenerWindowStateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
instance M34.QObjectPtr ListenerWindowState where
toQObject (ListenerWindowState ptr') = M34.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerWindowStateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
toQObject (ListenerWindowStateGc fptr' ptr') = M34.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QObjectConst -> HoppyF.Ptr M34.QObject) $ castListenerWindowStateToQObject $ (HoppyF.castPtr :: HoppyF.Ptr ListenerWindowState -> HoppyF.Ptr ListenerWindowStateConst) ptr'
listenerWindowState_new :: (M68.QtWindowState -> HoppyP.IO ()) -> HoppyP.IO ListenerWindowState
listenerWindowState_new arg'1 =
M182.callbackWindowStateVoid_new arg'1 >>= \arg'1' ->
HoppyP.fmap ListenerWindowState
(listenerWindowState_new' arg'1')
listenerWindowState_newWithParent :: (M34.QObjectPtr arg'2) => (M68.QtWindowState -> HoppyP.IO ()) -> arg'2 -> HoppyP.IO ListenerWindowState
listenerWindowState_newWithParent arg'1 arg'2 =
M182.callbackWindowStateVoid_new arg'1 >>= \arg'1' ->
HoppyFHR.withCppPtr (M34.toQObject arg'2) $ \arg'2' ->
HoppyP.fmap ListenerWindowState
(listenerWindowState_newWithParent' arg'1' arg'2')
class ListenerWindowStateSuper a where
downToListenerWindowState :: a -> ListenerWindowState
instance ListenerWindowStateSuper M34.QObject where
downToListenerWindowState = castListenerWindowStateToNonconst . cast' . M34.castQObjectToConst
where
cast' (M34.QObjectConst ptr') = ListenerWindowStateConst $ castQObjectToListenerWindowState ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerWindowStateConstGc fptr' $ castQObjectToListenerWindowState ptr'
class ListenerWindowStateSuperConst a where
downToListenerWindowStateConst :: a -> ListenerWindowStateConst
instance ListenerWindowStateSuperConst M34.QObjectConst where
downToListenerWindowStateConst = cast'
where
cast' (M34.QObjectConst ptr') = ListenerWindowStateConst $ castQObjectToListenerWindowState ptr'
cast' (M34.QObjectConstGc fptr' ptr') = ListenerWindowStateConstGc fptr' $ castQObjectToListenerWindowState ptr'
instance HoppyFHR.Assignable (HoppyF.Ptr (HoppyF.Ptr ListenerWindowState)) ListenerWindowState where
assign ptr' value' = HoppyF.poke ptr' $ HoppyFHR.toPtr value'
instance HoppyFHR.Decodable (HoppyF.Ptr (HoppyF.Ptr ListenerWindowState)) ListenerWindowState where
decode = HoppyP.fmap ListenerWindowState . HoppyF.peek