QGraphicsItem.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QGraphicsItem (
  QGraphicsItemValue (..),
  QGraphicsItemConstPtr (..),
  acceptDrops,
  acceptHoverEvents,
  acceptTouchEvents,
  boundingRect,
  boundingRegionGranularity,
  childrenBoundingRect,
  clipPath,
  collidesWithItem,
  collidesWithPath,
  commonAncestorItem,
  contains,
  cursor,
  effectiveOpacity,
  filtersChildEvents,
  focusItem,
  focusProxy,
  hasCursor,
  hasFocus,
  isActive,
  isAncestorOf,
  isBlockedByModalPanel,
  isBlockedByModalPanelAll,
  isClipped,
  isEnabled,
  isObscured,
  isObscuredRaw,
  isObscuredRectF,
  isObscuredBy,
  isPanel,
  isSelected,
  isUnderMouse,
  isVisible,
  isVisibleTo,
  isWidget,
  isWindow,
  opacity,
  opaqueArea,
  panel,
  parentItem,
  pos,
  rotation,
  scale,
  scene,
  sceneBoundingRect,
  scenePos,
  shape,
  toolTip,
  topLevelItem,
  transformOriginPoint,
  itemType,
  x,
  y,
  zValue,
  QGraphicsItemPtr (..),
  advance,
  clearFocus,
  setCursor,
  ensureVisible,
  ensureVisibleRectFAll,
  ensureVisibleRaw,
  ensureVisibleRawAll,
  grabKeyboard,
  grabMouse,
  hide,
  installSceneEventFilter,
  moveBy,
  removeSceneEventFilter,
  resetTransform,
  scroll,
  scrollAll,
  setAcceptDrops,
  setAcceptHoverEvents,
  setAcceptTouchEvents,
  setActive,
  setBoundingRegionGranularity,
  setEnabled,
  setFiltersChildEvents,
  setFocus,
  setFocusProxy,
  setOpacity,
  setParentItem,
  setPosPointF,
  setPosRaw,
  setRotation,
  setScale,
  setSelected,
  setToolTip,
  setTransformOriginPointF,
  setTransformOriginPointRaw,
  setVisible,
  setX,
  setY,
  setZValue,
  show,
  stackBefore,
  ungrabKeyboard,
  ungrabMouse,
  unsetCursor,
  update,
  updateRectF,
  updateRaw,
  QGraphicsItemConst (..),
  castQGraphicsItemToConst,
  QGraphicsItem (..),
  castQGraphicsItemToNonconst,
  QGraphicsItemSuper (..),
  QGraphicsItemSuperConst (..),
  QGraphicsItemCacheMode (..),
  QGraphicsItemGraphicsItemChange (..),
  QGraphicsItemGraphicsItemFlag (..),
  QGraphicsItemGraphicsItemFlags,
  IsQGraphicsItemGraphicsItemFlags (..),
  itemAcceptsInputMethod,
  itemClipsChildrenToShape,
  itemClipsToShape,
  itemContainsChildrenInShape,
  itemDoesntPropagateOpacityToChildren,
  itemHasNoContents,
  itemIgnoresParentOpacity,
  itemIgnoresTransformations,
  itemIsFocusable,
  itemIsMovable,
  itemIsPanel,
  itemIsSelectable,
  itemNegativeZStacksBehindParent,
  itemSendsGeometryChanges,
  itemSendsScenePositionChanges,
  itemStacksBehindParent,
  itemUsesExtendedStyleOption,
  QGraphicsItemPanelModality (..),
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Core.HPointF as HPointF
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QPointF as M116
import qualified Graphics.UI.Qtah.Generated.Core.QRectF as M124
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QCursor as M256
import qualified Graphics.UI.Qtah.Generated.Gui.QPainterPath as M312
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsScene as M412
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QGraphicsItem_acceptDrops" acceptDrops' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_acceptHoverEvents" acceptHoverEvents' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_acceptTouchEvents" acceptTouchEvents' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_advance" advance' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_boundingRect" boundingRect' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QGraphicsItem_boundingRegionGranularity" boundingRegionGranularity' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_childrenBoundingRect" childrenBoundingRect' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QGraphicsItem_clearFocus" clearFocus' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_clipPath" clipPath' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M312.QPainterPathConst)
foreign import ccall "genpop__QGraphicsItem_collidesWithItem" collidesWithItem' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_collidesWithPath" collidesWithPath' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr M312.QPainterPathConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_commonAncestorItem" commonAncestorItem' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_contains" contains' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_cursor" cursor' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M256.QCursorConst)
foreign import ccall "genpop__QGraphicsItem_setCursor" setCursor' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M256.QCursorConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_effectiveOpacity" effectiveOpacity' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_ensureVisible" ensureVisible' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_ensureVisibleRectFAll" ensureVisibleRectFAll' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M124.QRectFConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_ensureVisibleRaw" ensureVisibleRaw' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_ensureVisibleRawAll" ensureVisibleRawAll' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_filtersChildEvents" filtersChildEvents' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_focusItem" focusItem' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_focusProxy" focusProxy' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_grabKeyboard" grabKeyboard' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_grabMouse" grabMouse' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_hasCursor" hasCursor' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_hasFocus" hasFocus' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_hide" hide' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_installSceneEventFilter" installSceneEventFilter' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_isActive" isActive' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isAncestorOf" isAncestorOf' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isBlockedByModalPanel" isBlockedByModalPanel' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isBlockedByModalPanelAll" isBlockedByModalPanelAll' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr (HoppyF.Ptr QGraphicsItem) -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isClipped" isClipped' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isEnabled" isEnabled' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isObscured" isObscured' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isObscuredRaw" isObscuredRaw' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isObscuredRectF" isObscuredRectF' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isObscuredBy" isObscuredBy' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isPanel" isPanel' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isSelected" isSelected' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isUnderMouse" isUnderMouse' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isVisible" isVisible' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isVisibleTo" isVisibleTo' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isWidget" isWidget' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_isWindow" isWindow' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsItem_moveBy" moveBy' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_opacity" opacity' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_opaqueArea" opaqueArea' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M312.QPainterPathConst)
foreign import ccall "genpop__QGraphicsItem_panel" panel' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_parentItem" parentItem' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_pos" pos' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QGraphicsItem_removeSceneEventFilter" removeSceneEventFilter' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_resetTransform" resetTransform' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_rotation" rotation' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_scale" scale' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_scene" scene' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M412.QGraphicsScene)
foreign import ccall "genpop__QGraphicsItem_sceneBoundingRect" sceneBoundingRect' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QGraphicsItem_scenePos" scenePos' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QGraphicsItem_scroll" scroll' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_scrollAll" scrollAll' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setAcceptDrops" setAcceptDrops' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setAcceptHoverEvents" setAcceptHoverEvents' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setAcceptTouchEvents" setAcceptTouchEvents' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setActive" setActive' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setBoundingRegionGranularity" setBoundingRegionGranularity' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setEnabled" setEnabled' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setFiltersChildEvents" setFiltersChildEvents' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setFocus" setFocus' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setFocusProxy" setFocusProxy' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setOpacity" setOpacity' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setParentItem" setParentItem' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setPosPointF" setPosPointF' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setPosRaw" setPosRaw' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setRotation" setRotation' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setScale" setScale' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setSelected" setSelected' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setToolTip" setToolTip' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setTransformOriginPointF" setTransformOriginPointF' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setTransformOriginPointRaw" setTransformOriginPointRaw' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setVisible" setVisible' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setX" setX' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setY" setY' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_setZValue" setZValue' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_shape" shape' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M312.QPainterPathConst)
foreign import ccall "genpop__QGraphicsItem_show" show' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_stackBefore" stackBefore' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_toolTip" toolTip' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QGraphicsItem_topLevelItem" topLevelItem' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr QGraphicsItem)
foreign import ccall "genpop__QGraphicsItem_transformOriginPoint" transformOriginPoint' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QGraphicsItem_itemType" itemType' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QGraphicsItem_ungrabKeyboard" ungrabKeyboard' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_ungrabMouse" ungrabMouse' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_unsetCursor" unsetCursor' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_update" update' ::  HoppyF.Ptr QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_updateRectF" updateRectF' ::  HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_updateRaw" updateRaw' ::  HoppyF.Ptr QGraphicsItem -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsItem_x" x' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_y" y' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsItem_zValue" zValue' ::  HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "gendel__QGraphicsItem" delete'QGraphicsItem :: HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO ()
foreign import ccall "&gendel__QGraphicsItem" deletePtr'QGraphicsItem :: HoppyF.FunPtr (HoppyF.Ptr QGraphicsItemConst -> HoppyP.IO ())

class QGraphicsItemValue a where
  withQGraphicsItemPtr :: a -> (QGraphicsItemConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QGraphicsItemConstPtr a => QGraphicsItemValue a where
  withQGraphicsItemPtr = HoppyP.flip ($) . toQGraphicsItemConst

class (HoppyFHR.CppPtr this) => QGraphicsItemConstPtr this where
  toQGraphicsItemConst :: this -> QGraphicsItemConst

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

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

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

boundingRect :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M124.QRectF)
boundingRect arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M124.QRectFConst) =<<
  (boundingRect' arg'1')

boundingRegionGranularity :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
boundingRegionGranularity arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (boundingRegionGranularity' arg'1')

childrenBoundingRect :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M124.QRectF)
childrenBoundingRect arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M124.QRectFConst) =<<
  (childrenBoundingRect' arg'1')

clipPath :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M312.QPainterPath)
clipPath arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M312.QPainterPathConst) =<<
  (clipPath' arg'1')

collidesWithItem :: (QGraphicsItemValue this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
collidesWithItem arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (collidesWithItem' arg'1' arg'2')

collidesWithPath :: (QGraphicsItemValue this, M312.QPainterPathValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
collidesWithPath arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M312.withQPainterPathPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (collidesWithPath' arg'1' arg'2')

commonAncestorItem :: (QGraphicsItemValue this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QGraphicsItem)
commonAncestorItem arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QGraphicsItem
  (commonAncestorItem' arg'1' arg'2')

contains :: (QGraphicsItemValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
contains arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (contains' arg'1' arg'2')

cursor :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M256.QCursor)
cursor arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M256.QCursorConst) =<<
  (cursor' arg'1')

effectiveOpacity :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
effectiveOpacity arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (effectiveOpacity' arg'1')

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

focusItem :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QGraphicsItem)
focusItem arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsItem
  (focusItem' arg'1')

focusProxy :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QGraphicsItem)
focusProxy arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsItem
  (focusProxy' arg'1')

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

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

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

isAncestorOf :: (QGraphicsItemValue this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isAncestorOf arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isAncestorOf' arg'1' arg'2')

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

isBlockedByModalPanelAll :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyF.Ptr (HoppyF.Ptr QGraphicsItem)) -> (HoppyP.IO HoppyP.Bool)
isBlockedByModalPanelAll arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isBlockedByModalPanelAll' arg'1' arg'2')

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

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

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

isObscuredRaw :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO HoppyP.Bool)
isObscuredRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'5 >>= \arg'5' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isObscuredRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

isObscuredRectF :: (QGraphicsItemValue this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isObscuredRectF arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isObscuredRectF' arg'1' arg'2')

isObscuredBy :: (QGraphicsItemValue this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isObscuredBy arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isObscuredBy' arg'1' arg'2')

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

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

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

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

isVisibleTo :: (QGraphicsItemValue this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
isVisibleTo arg'1 arg'2 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isVisibleTo' arg'1' arg'2')

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

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

opacity :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
opacity arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (opacity' arg'1')

opaqueArea :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M312.QPainterPath)
opaqueArea arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M312.QPainterPathConst) =<<
  (opaqueArea' arg'1')

panel :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QGraphicsItem)
panel arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsItem
  (panel' arg'1')

parentItem :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QGraphicsItem)
parentItem arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsItem
  (parentItem' arg'1')

pos :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
pos arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (pos' arg'1')

rotation :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
rotation arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (rotation' arg'1')

scale :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
scale arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (scale' arg'1')

scene :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M412.QGraphicsScene)
scene arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M412.QGraphicsScene
  (scene' arg'1')

sceneBoundingRect :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M124.QRectF)
sceneBoundingRect arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M124.QRectFConst) =<<
  (sceneBoundingRect' arg'1')

scenePos :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
scenePos arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (scenePos' arg'1')

shape :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M312.QPainterPath)
shape arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M312.QPainterPathConst) =<<
  (shape' arg'1')

toolTip :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
toolTip arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (toolTip' arg'1')

topLevelItem :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QGraphicsItem)
topLevelItem arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsItem
  (topLevelItem' arg'1')

transformOriginPoint :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HPointF.HPointF)
transformOriginPoint arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M116.QPointFConst) =<<
  (transformOriginPoint' arg'1')

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

x :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
x arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (x' arg'1')

y :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
y arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (y' arg'1')

zValue :: (QGraphicsItemValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
zValue arg'1 =
  withQGraphicsItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (zValue' arg'1')

class (QGraphicsItemConstPtr this) => QGraphicsItemPtr this where
  toQGraphicsItem :: this -> QGraphicsItem

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

clearFocus :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clearFocus arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (clearFocus' arg'1')

setCursor :: (QGraphicsItemPtr this, M256.QCursorValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setCursor arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M256.withQCursorPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setCursor' arg'1' arg'2')

ensureVisible :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
ensureVisible arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (ensureVisible' arg'1')

ensureVisibleRectFAll :: (QGraphicsItemPtr this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
ensureVisibleRectFAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (ensureVisibleRectFAll' arg'1' arg'2' arg'3' arg'4')

ensureVisibleRaw :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
ensureVisibleRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'5 >>= \arg'5' ->
  (ensureVisibleRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

ensureVisibleRawAll :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
ensureVisibleRawAll arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'6 >>= \arg'6' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'7 >>= \arg'7' ->
  (ensureVisibleRawAll' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7')

grabKeyboard :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
grabKeyboard arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (grabKeyboard' arg'1')

grabMouse :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
grabMouse arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (grabMouse' arg'1')

hide :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
hide arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (hide' arg'1')

installSceneEventFilter :: (QGraphicsItemPtr this, QGraphicsItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
installSceneEventFilter arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQGraphicsItem arg'2) $ \arg'2' ->
  (installSceneEventFilter' arg'1' arg'2')

moveBy :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
moveBy arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (moveBy' arg'1' arg'2' arg'3')

removeSceneEventFilter :: (QGraphicsItemPtr this, QGraphicsItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeSceneEventFilter arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQGraphicsItem arg'2) $ \arg'2' ->
  (removeSceneEventFilter' arg'1' arg'2')

resetTransform :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
resetTransform arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (resetTransform' arg'1')

scroll :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
scroll arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (scroll' arg'1' arg'2' arg'3')

scrollAll :: (QGraphicsItemPtr this, M124.QRectFValue arg'4) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (arg'4) -> (HoppyP.IO ())
scrollAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  M124.withQRectFPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (scrollAll' arg'1' arg'2' arg'3' arg'4')

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

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

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

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

setBoundingRegionGranularity :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setBoundingRegionGranularity arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setBoundingRegionGranularity' arg'1' arg'2')

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

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

setFocus :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setFocus arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (setFocus' arg'1')

setFocusProxy :: (QGraphicsItemPtr this, QGraphicsItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFocusProxy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQGraphicsItem arg'2) $ \arg'2' ->
  (setFocusProxy' arg'1' arg'2')

setOpacity :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setOpacity arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setOpacity' arg'1' arg'2')

setParentItem :: (QGraphicsItemPtr this, QGraphicsItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setParentItem arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQGraphicsItem arg'2) $ \arg'2' ->
  (setParentItem' arg'1' arg'2')

setPosPointF :: (QGraphicsItemPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setPosPointF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setPosPointF' arg'1' arg'2')

setPosRaw :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setPosRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (setPosRaw' arg'1' arg'2' arg'3')

setRotation :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setRotation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setRotation' arg'1' arg'2')

setScale :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setScale arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setScale' arg'1' arg'2')

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

setToolTip :: (QGraphicsItemPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setToolTip arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setToolTip' arg'1' arg'2')

setTransformOriginPointF :: (QGraphicsItemPtr this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTransformOriginPointF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setTransformOriginPointF' arg'1' arg'2')

setTransformOriginPointRaw :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setTransformOriginPointRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (setTransformOriginPointRaw' arg'1' arg'2' arg'3')

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

setX :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setX arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setX' arg'1' arg'2')

setY :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setY arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setY' arg'1' arg'2')

setZValue :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setZValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setZValue' arg'1' arg'2')

show :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
show arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (show' arg'1')

stackBefore :: (QGraphicsItemPtr this, QGraphicsItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
stackBefore arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  withQGraphicsItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (stackBefore' arg'1' arg'2')

ungrabKeyboard :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
ungrabKeyboard arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (ungrabKeyboard' arg'1')

ungrabMouse :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
ungrabMouse arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (ungrabMouse' arg'1')

unsetCursor :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
unsetCursor arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (unsetCursor' arg'1')

update :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
update arg'1 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (update' arg'1')

updateRectF :: (QGraphicsItemPtr this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
updateRectF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (updateRectF' arg'1' arg'2')

updateRaw :: (QGraphicsItemPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
updateRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'5 >>= \arg'5' ->
  (updateRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

data QGraphicsItemConst =
    QGraphicsItemConst (HoppyF.Ptr QGraphicsItemConst)
  | QGraphicsItemConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGraphicsItemConst)
  deriving (HoppyP.Show)

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

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

castQGraphicsItemToConst :: QGraphicsItem -> QGraphicsItemConst
castQGraphicsItemToConst (QGraphicsItem ptr') = QGraphicsItemConst $ HoppyF.castPtr ptr'
castQGraphicsItemToConst (QGraphicsItemGc fptr' ptr') = QGraphicsItemConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QGraphicsItemConstPtr QGraphicsItemConst where
  toQGraphicsItemConst = HoppyP.id

data QGraphicsItem =
    QGraphicsItem (HoppyF.Ptr QGraphicsItem)
  | QGraphicsItemGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGraphicsItem)
  deriving (HoppyP.Show)

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

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

castQGraphicsItemToNonconst :: QGraphicsItemConst -> QGraphicsItem
castQGraphicsItemToNonconst (QGraphicsItemConst ptr') = QGraphicsItem $ HoppyF.castPtr ptr'
castQGraphicsItemToNonconst (QGraphicsItemConstGc fptr' ptr') = QGraphicsItemGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QGraphicsItemConstPtr QGraphicsItem where
  toQGraphicsItemConst (QGraphicsItem ptr') = QGraphicsItemConst $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItemConst) ptr'
  toQGraphicsItemConst (QGraphicsItemGc fptr' ptr') = QGraphicsItemConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsItem -> HoppyF.Ptr QGraphicsItemConst) ptr'

instance QGraphicsItemPtr QGraphicsItem where
  toQGraphicsItem = HoppyP.id

class QGraphicsItemSuper a where
  downToQGraphicsItem :: a -> QGraphicsItem


class QGraphicsItemSuperConst a where
  downToQGraphicsItemConst :: a -> QGraphicsItemConst


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

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

data QGraphicsItemCacheMode =
  NoCache
  | ItemCoordinateCache
  | DeviceCoordinateCache
  | UnknownQGraphicsItemCacheMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsItemCacheMode where
  fromCppEnum NoCache = 0
  fromCppEnum ItemCoordinateCache = 1
  fromCppEnum DeviceCoordinateCache = 2
  fromCppEnum (UnknownQGraphicsItemCacheMode n) = n
  
  toCppEnum (0) = NoCache
  toCppEnum (1) = ItemCoordinateCache
  toCppEnum (2) = DeviceCoordinateCache
  toCppEnum n = UnknownQGraphicsItemCacheMode n

instance HoppyP.Eq QGraphicsItemCacheMode where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QGraphicsItemCacheMode where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

data QGraphicsItemGraphicsItemChange =
  ItemEnabledChange
  | ItemEnabledHasChanged
  | ItemMatrixChange
  | ItemPositionChange
  | ItemPositionHasChanged
  | ItemTransformChange
  | ItemTransformHasChanged
  | ItemRotationChange
  | ItemRotationHasChanged
  | ItemScaleChange
  | ItemScaleHasChanged
  | ItemTransformOriginPointChange
  | ItemTransformOriginPointHasChanged
  | ItemSelectedChange
  | ItemSelectedHasChanged
  | ItemVisibleChange
  | ItemVisibleHasChanged
  | ItemParentChange
  | ItemParentHasChanged
  | ItemChildAddedChange
  | ItemChildRemovedChange
  | ItemSceneChange
  | ItemSceneHasChanged
  | ItemCursorChange
  | ItemCursorHasChanged
  | ItemToolTipChange
  | ItemToolTipHasChanged
  | ItemFlagsChange
  | ItemFlagsHaveChanged
  | ItemZValueChange
  | ItemZValueHasChanged
  | ItemOpacityChange
  | ItemOpacityHasChanged
  | ItemScenePositionHasChanged
  | UnknownQGraphicsItemGraphicsItemChange (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsItemGraphicsItemChange where
  fromCppEnum ItemEnabledChange = 3
  fromCppEnum ItemEnabledHasChanged = 13
  fromCppEnum ItemMatrixChange = 1
  fromCppEnum ItemPositionChange = 0
  fromCppEnum ItemPositionHasChanged = 9
  fromCppEnum ItemTransformChange = 8
  fromCppEnum ItemTransformHasChanged = 10
  fromCppEnum ItemRotationChange = 28
  fromCppEnum ItemRotationHasChanged = 29
  fromCppEnum ItemScaleChange = 30
  fromCppEnum ItemScaleHasChanged = 31
  fromCppEnum ItemTransformOriginPointChange = 32
  fromCppEnum ItemTransformOriginPointHasChanged = 33
  fromCppEnum ItemSelectedChange = 4
  fromCppEnum ItemSelectedHasChanged = 14
  fromCppEnum ItemVisibleChange = 2
  fromCppEnum ItemVisibleHasChanged = 12
  fromCppEnum ItemParentChange = 5
  fromCppEnum ItemParentHasChanged = 15
  fromCppEnum ItemChildAddedChange = 6
  fromCppEnum ItemChildRemovedChange = 7
  fromCppEnum ItemSceneChange = 11
  fromCppEnum ItemSceneHasChanged = 16
  fromCppEnum ItemCursorChange = 17
  fromCppEnum ItemCursorHasChanged = 18
  fromCppEnum ItemToolTipChange = 19
  fromCppEnum ItemToolTipHasChanged = 20
  fromCppEnum ItemFlagsChange = 21
  fromCppEnum ItemFlagsHaveChanged = 22
  fromCppEnum ItemZValueChange = 23
  fromCppEnum ItemZValueHasChanged = 24
  fromCppEnum ItemOpacityChange = 25
  fromCppEnum ItemOpacityHasChanged = 26
  fromCppEnum ItemScenePositionHasChanged = 27
  fromCppEnum (UnknownQGraphicsItemGraphicsItemChange n) = n
  
  toCppEnum (0) = ItemPositionChange
  toCppEnum (1) = ItemMatrixChange
  toCppEnum (2) = ItemVisibleChange
  toCppEnum (3) = ItemEnabledChange
  toCppEnum (4) = ItemSelectedChange
  toCppEnum (5) = ItemParentChange
  toCppEnum (6) = ItemChildAddedChange
  toCppEnum (7) = ItemChildRemovedChange
  toCppEnum (8) = ItemTransformChange
  toCppEnum (9) = ItemPositionHasChanged
  toCppEnum (10) = ItemTransformHasChanged
  toCppEnum (11) = ItemSceneChange
  toCppEnum (12) = ItemVisibleHasChanged
  toCppEnum (13) = ItemEnabledHasChanged
  toCppEnum (14) = ItemSelectedHasChanged
  toCppEnum (15) = ItemParentHasChanged
  toCppEnum (16) = ItemSceneHasChanged
  toCppEnum (17) = ItemCursorChange
  toCppEnum (18) = ItemCursorHasChanged
  toCppEnum (19) = ItemToolTipChange
  toCppEnum (20) = ItemToolTipHasChanged
  toCppEnum (21) = ItemFlagsChange
  toCppEnum (22) = ItemFlagsHaveChanged
  toCppEnum (23) = ItemZValueChange
  toCppEnum (24) = ItemZValueHasChanged
  toCppEnum (25) = ItemOpacityChange
  toCppEnum (26) = ItemOpacityHasChanged
  toCppEnum (27) = ItemScenePositionHasChanged
  toCppEnum (28) = ItemRotationChange
  toCppEnum (29) = ItemRotationHasChanged
  toCppEnum (30) = ItemScaleChange
  toCppEnum (31) = ItemScaleHasChanged
  toCppEnum (32) = ItemTransformOriginPointChange
  toCppEnum (33) = ItemTransformOriginPointHasChanged
  toCppEnum n = UnknownQGraphicsItemGraphicsItemChange n

instance HoppyP.Eq QGraphicsItemGraphicsItemChange where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QGraphicsItemGraphicsItemChange where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

data QGraphicsItemGraphicsItemFlag =
  ItemIsMovable
  | ItemIsSelectable
  | ItemIsFocusable
  | ItemClipsToShape
  | ItemClipsChildrenToShape
  | ItemIgnoresTransformations
  | ItemIgnoresParentOpacity
  | ItemDoesntPropagateOpacityToChildren
  | ItemStacksBehindParent
  | ItemUsesExtendedStyleOption
  | ItemHasNoContents
  | ItemSendsGeometryChanges
  | ItemAcceptsInputMethod
  | ItemNegativeZStacksBehindParent
  | ItemIsPanel
  | ItemSendsScenePositionChanges
  | ItemContainsChildrenInShape
  | UnknownQGraphicsItemGraphicsItemFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsItemGraphicsItemFlag where
  fromCppEnum ItemIsMovable = 1
  fromCppEnum ItemIsSelectable = 2
  fromCppEnum ItemIsFocusable = 4
  fromCppEnum ItemClipsToShape = 8
  fromCppEnum ItemClipsChildrenToShape = 16
  fromCppEnum ItemIgnoresTransformations = 32
  fromCppEnum ItemIgnoresParentOpacity = 64
  fromCppEnum ItemDoesntPropagateOpacityToChildren = 128
  fromCppEnum ItemStacksBehindParent = 256
  fromCppEnum ItemUsesExtendedStyleOption = 512
  fromCppEnum ItemHasNoContents = 1024
  fromCppEnum ItemSendsGeometryChanges = 2048
  fromCppEnum ItemAcceptsInputMethod = 4096
  fromCppEnum ItemNegativeZStacksBehindParent = 8192
  fromCppEnum ItemIsPanel = 16384
  fromCppEnum ItemSendsScenePositionChanges = 65536
  fromCppEnum ItemContainsChildrenInShape = 524288
  fromCppEnum (UnknownQGraphicsItemGraphicsItemFlag n) = n
  
  toCppEnum (1) = ItemIsMovable
  toCppEnum (2) = ItemIsSelectable
  toCppEnum (4) = ItemIsFocusable
  toCppEnum (8) = ItemClipsToShape
  toCppEnum (16) = ItemClipsChildrenToShape
  toCppEnum (32) = ItemIgnoresTransformations
  toCppEnum (64) = ItemIgnoresParentOpacity
  toCppEnum (128) = ItemDoesntPropagateOpacityToChildren
  toCppEnum (256) = ItemStacksBehindParent
  toCppEnum (512) = ItemUsesExtendedStyleOption
  toCppEnum (1024) = ItemHasNoContents
  toCppEnum (2048) = ItemSendsGeometryChanges
  toCppEnum (4096) = ItemAcceptsInputMethod
  toCppEnum (8192) = ItemNegativeZStacksBehindParent
  toCppEnum (16384) = ItemIsPanel
  toCppEnum (65536) = ItemSendsScenePositionChanges
  toCppEnum (524288) = ItemContainsChildrenInShape
  toCppEnum n = UnknownQGraphicsItemGraphicsItemFlag n

instance HoppyP.Eq QGraphicsItemGraphicsItemFlag where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QGraphicsItemGraphicsItemFlag where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

newtype QGraphicsItemGraphicsItemFlags = QGraphicsItemGraphicsItemFlags (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QGraphicsItemGraphicsItemFlag QGraphicsItemGraphicsItemFlags where
  enumToFlags = QGraphicsItemGraphicsItemFlags . QtahFHR.fromCppEnum
  flagsToEnum (QGraphicsItemGraphicsItemFlags x') = QtahFHR.toCppEnum x'

class IsQGraphicsItemGraphicsItemFlags a where
  toQGraphicsItemGraphicsItemFlags :: a -> QGraphicsItemGraphicsItemFlags

instance IsQGraphicsItemGraphicsItemFlags QGraphicsItemGraphicsItemFlags where toQGraphicsItemGraphicsItemFlags = QtahP.id
instance IsQGraphicsItemGraphicsItemFlags QGraphicsItemGraphicsItemFlag where toQGraphicsItemGraphicsItemFlags = QtahFlags.enumToFlags
instance IsQGraphicsItemGraphicsItemFlags (HoppyFC.CInt) where toQGraphicsItemGraphicsItemFlags = QtahFlags.numToFlags

itemAcceptsInputMethod :: QGraphicsItemGraphicsItemFlags
itemAcceptsInputMethod = QGraphicsItemGraphicsItemFlags (4096)

itemClipsChildrenToShape :: QGraphicsItemGraphicsItemFlags
itemClipsChildrenToShape = QGraphicsItemGraphicsItemFlags (16)

itemClipsToShape :: QGraphicsItemGraphicsItemFlags
itemClipsToShape = QGraphicsItemGraphicsItemFlags (8)

itemContainsChildrenInShape :: QGraphicsItemGraphicsItemFlags
itemContainsChildrenInShape = QGraphicsItemGraphicsItemFlags (524288)

itemDoesntPropagateOpacityToChildren :: QGraphicsItemGraphicsItemFlags
itemDoesntPropagateOpacityToChildren = QGraphicsItemGraphicsItemFlags (128)

itemHasNoContents :: QGraphicsItemGraphicsItemFlags
itemHasNoContents = QGraphicsItemGraphicsItemFlags (1024)

itemIgnoresParentOpacity :: QGraphicsItemGraphicsItemFlags
itemIgnoresParentOpacity = QGraphicsItemGraphicsItemFlags (64)

itemIgnoresTransformations :: QGraphicsItemGraphicsItemFlags
itemIgnoresTransformations = QGraphicsItemGraphicsItemFlags (32)

itemIsFocusable :: QGraphicsItemGraphicsItemFlags
itemIsFocusable = QGraphicsItemGraphicsItemFlags (4)

itemIsMovable :: QGraphicsItemGraphicsItemFlags
itemIsMovable = QGraphicsItemGraphicsItemFlags (1)

itemIsPanel :: QGraphicsItemGraphicsItemFlags
itemIsPanel = QGraphicsItemGraphicsItemFlags (16384)

itemIsSelectable :: QGraphicsItemGraphicsItemFlags
itemIsSelectable = QGraphicsItemGraphicsItemFlags (2)

itemNegativeZStacksBehindParent :: QGraphicsItemGraphicsItemFlags
itemNegativeZStacksBehindParent = QGraphicsItemGraphicsItemFlags (8192)

itemSendsGeometryChanges :: QGraphicsItemGraphicsItemFlags
itemSendsGeometryChanges = QGraphicsItemGraphicsItemFlags (2048)

itemSendsScenePositionChanges :: QGraphicsItemGraphicsItemFlags
itemSendsScenePositionChanges = QGraphicsItemGraphicsItemFlags (65536)

itemStacksBehindParent :: QGraphicsItemGraphicsItemFlags
itemStacksBehindParent = QGraphicsItemGraphicsItemFlags (256)

itemUsesExtendedStyleOption :: QGraphicsItemGraphicsItemFlags
itemUsesExtendedStyleOption = QGraphicsItemGraphicsItemFlags (512)

instance QtahDB.Bits QGraphicsItemGraphicsItemFlags where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum

data QGraphicsItemPanelModality =
  NonModal
  | PanelModal
  | SceneModal
  | UnknownQGraphicsItemPanelModality (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsItemPanelModality where
  fromCppEnum NonModal = 0
  fromCppEnum PanelModal = 1
  fromCppEnum SceneModal = 2
  fromCppEnum (UnknownQGraphicsItemPanelModality n) = n
  
  toCppEnum (0) = NonModal
  toCppEnum (1) = PanelModal
  toCppEnum (2) = SceneModal
  toCppEnum n = UnknownQGraphicsItemPanelModality n

instance HoppyP.Eq QGraphicsItemPanelModality where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QGraphicsItemPanelModality where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)