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

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</