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

module Graphics.UI.Qtah.Generated.Widgets.QGraphicsScene (
  castQGraphicsSceneToQObject,
  castQObjectToQGraphicsScene,
  QGraphicsSceneValue (..),
  QGraphicsSceneConstPtr (..),
  activePanel,
  backgroundBrush,
  bspTreeDepth,
  focusItem,
  font,
  foregroundBrush,
  hasFocus,
  height,
  isActive,
  itemAtPointF,
  itemAtRaw,
  itemsBoundingRect,
  minimumRenderSize,
  mouseGrabberItem,
  sceneRect,
  selectionArea,
  stickyFocus,
  width,
  QGraphicsScenePtr (..),
  addEllipseRectF,
  addEllipseRectFAll,
  addEllipseRaw,
  addEllipseRawAll,
  addItem,
  addPolygon,
  addPolygonAll,
  addRect,
  addRectAll,
  addRectRaw,
  addRectRawAll,
  clearFocus,
  setFont,
  invalidate,
  removeItem,
  sendEvent,
  setActivePanel,
  setBackgroundBrush,
  setBspTreeDepth,
  setFocus,
  setFocusAll,
  setFocusItem,
  setFocusItemAll,
  setForegroundBrush,
  setMinimumRenderSize,
  setSceneRect,
  setSceneRectRaw,
  setSelectionAreaTransform,
  setSelectionArea,
  setStickyFocus,
  update,
  QGraphicsSceneConst (..),
  castQGraphicsSceneToConst,
  QGraphicsScene (..),
  castQGraphicsSceneToNonconst,
  new,
  newWithParent,
  newWithRect,
  newWithRaw,
  QGraphicsSceneSuper (..),
  QGraphicsSceneSuperConst (..),
  QGraphicsSceneItemIndexMethod (..),
  QGraphicsSceneSceneLayer (..),
  QGraphicsSceneSceneLayers,
  IsQGraphicsSceneSceneLayers (..),
  allLayers,
  backgroundLayer,
  foregroundLayer,
  itemLayer,
  ) 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.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QEvent as M34
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
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.Types as M190
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QBrush as M246
import qualified Graphics.UI.Qtah.Generated.Gui.QFont as M276
import qualified Graphics.UI.Qtah.Generated.Gui.QPainterPath as M312
import qualified Graphics.UI.Qtah.Generated.Gui.QPen as M314
import qualified Graphics.UI.Qtah.Generated.Gui.QPolygonF as M320
import qualified Graphics.UI.Qtah.Generated.Gui.QTransform as M336
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsEllipseItem as M402
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsItem as M404
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsPolygonItem as M408
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QGraphicsRectItem as M410
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QGraphicsScene_new" new' ::  HoppyP.IO (HoppyF.Ptr QGraphicsScene)
foreign import ccall "genpop__QGraphicsScene_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QGraphicsScene)
foreign import ccall "genpop__QGraphicsScene_newWithRect" newWithRect' ::  HoppyF.Ptr M124.QRectFConst -> HoppyP.IO (HoppyF.Ptr QGraphicsScene)
foreign import ccall "genpop__QGraphicsScene_newWithRaw" newWithRaw' ::  HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QGraphicsScene)
foreign import ccall "genpop__QGraphicsScene_activePanel" activePanel' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M404.QGraphicsItem)
foreign import ccall "genpop__QGraphicsScene_addEllipseRectF" addEllipseRectF' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO (HoppyF.Ptr M402.QGraphicsEllipseItem)
foreign import ccall "genpop__QGraphicsScene_addEllipseRectFAll" addEllipseRectFAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M124.QRectFConst -> HoppyF.Ptr M314.QPenConst -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO (HoppyF.Ptr M402.QGraphicsEllipseItem)
foreign import ccall "genpop__QGraphicsScene_addEllipseRaw" addEllipseRaw' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr M402.QGraphicsEllipseItem)
foreign import ccall "genpop__QGraphicsScene_addEllipseRawAll" addEllipseRawAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyF.Ptr M314.QPenConst -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO (HoppyF.Ptr M402.QGraphicsEllipseItem)
foreign import ccall "genpop__QGraphicsScene_addItem" addItem' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_addPolygon" addPolygon' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M320.QPolygonFConst -> HoppyP.IO (HoppyF.Ptr M408.QGraphicsPolygonItem)
foreign import ccall "genpop__QGraphicsScene_addPolygonAll" addPolygonAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M320.QPolygonFConst -> HoppyF.Ptr M314.QPenConst -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO (HoppyF.Ptr M408.QGraphicsPolygonItem)
foreign import ccall "genpop__QGraphicsScene_addRect" addRect' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO (HoppyF.Ptr M410.QGraphicsRectItem)
foreign import ccall "genpop__QGraphicsScene_addRectAll" addRectAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M124.QRectFConst -> HoppyF.Ptr M314.QPenConst -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO (HoppyF.Ptr M410.QGraphicsRectItem)
foreign import ccall "genpop__QGraphicsScene_addRectRaw" addRectRaw' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr M410.QGraphicsRectItem)
foreign import ccall "genpop__QGraphicsScene_addRectRawAll" addRectRawAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyF.Ptr M314.QPenConst -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO (HoppyF.Ptr M410.QGraphicsRectItem)
foreign import ccall "genpop__QGraphicsScene_backgroundBrush" backgroundBrush' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M246.QBrushConst)
foreign import ccall "genpop__QGraphicsScene_bspTreeDepth" bspTreeDepth' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QGraphicsScene_clearFocus" clearFocus' ::  HoppyF.Ptr QGraphicsScene -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_focusItem" focusItem' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M404.QGraphicsItem)
foreign import ccall "genpop__QGraphicsScene_font" font' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M276.QFontConst)
foreign import ccall "genpop__QGraphicsScene_setFont" setFont' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M276.QFontConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_foregroundBrush" foregroundBrush' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M246.QBrushConst)
foreign import ccall "genpop__QGraphicsScene_hasFocus" hasFocus' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsScene_height" height' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsScene_invalidate" invalidate' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_isActive" isActive' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsScene_itemAtPointF" itemAtPointF' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyF.Ptr M116.QPointFConst -> HoppyF.Ptr M336.QTransformConst -> HoppyP.IO (HoppyF.Ptr M404.QGraphicsItem)
foreign import ccall "genpop__QGraphicsScene_itemAtRaw" itemAtRaw' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyF.Ptr M336.QTransformConst -> HoppyP.IO (HoppyF.Ptr M404.QGraphicsItem)
foreign import ccall "genpop__QGraphicsScene_itemsBoundingRect" itemsBoundingRect' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QGraphicsScene_minimumRenderSize" minimumRenderSize' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QGraphicsScene_mouseGrabberItem" mouseGrabberItem' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M404.QGraphicsItem)
foreign import ccall "genpop__QGraphicsScene_removeItem" removeItem' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_sceneRect" sceneRect' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QGraphicsScene_selectionArea" selectionArea' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO (HoppyF.Ptr M312.QPainterPathConst)
foreign import ccall "genpop__QGraphicsScene_sendEvent" sendEvent' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyF.Ptr M34.QEvent -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsScene_setActivePanel" setActivePanel' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setBackgroundBrush" setBackgroundBrush' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setBspTreeDepth" setBspTreeDepth' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setFocus" setFocus' ::  HoppyF.Ptr QGraphicsScene -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setFocusAll" setFocusAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setFocusItem" setFocusItem' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setFocusItemAll" setFocusItemAll' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M404.QGraphicsItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setForegroundBrush" setForegroundBrush' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setMinimumRenderSize" setMinimumRenderSize' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setSceneRect" setSceneRect' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M124.QRectFConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setSceneRectRaw" setSceneRectRaw' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setSelectionAreaTransform" setSelectionAreaTransform' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M312.QPainterPathConst -> HoppyF.Ptr M336.QTransformConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setSelectionArea" setSelectionArea' ::  HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr M312.QPainterPathConst -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_setStickyFocus" setStickyFocus' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_stickyFocus" stickyFocus' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGraphicsScene_update" update' ::  HoppyF.Ptr QGraphicsScene -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QGraphicsScene_width" width' ::  HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "gencast__QGraphicsScene__QObject" castQGraphicsSceneToQObject :: HoppyF.Ptr QGraphicsSceneConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QGraphicsScene" castQObjectToQGraphicsScene :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QGraphicsSceneConst
foreign import ccall "gendel__QGraphicsScene" delete'QGraphicsScene :: HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO ()
foreign import ccall "&gendel__QGraphicsScene" deletePtr'QGraphicsScene :: HoppyF.FunPtr (HoppyF.Ptr QGraphicsSceneConst -> HoppyP.IO ())

class QGraphicsSceneValue a where
  withQGraphicsScenePtr :: a -> (QGraphicsSceneConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QGraphicsSceneConstPtr a => QGraphicsSceneValue a where
  withQGraphicsScenePtr = HoppyP.flip ($) . toQGraphicsSceneConst

class (M94.QObjectConstPtr this) => QGraphicsSceneConstPtr this where
  toQGraphicsSceneConst :: this -> QGraphicsSceneConst

activePanel :: (QGraphicsSceneValue this) => (this) {- ^ this -} -> (HoppyP.IO M404.QGraphicsItem)
activePanel arg'1 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M404.QGraphicsItem
  (activePanel' arg'1')

backgroundBrush :: (QGraphicsSceneValue this) => (this) {- ^ this -} -> (HoppyP.IO M246.QBrush)
backgroundBrush arg'1 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M246.QBrushConst) =<<
  (backgroundBrush' arg'1')

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

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

font :: (QGraphicsSceneValue this) => (this) {- ^ this -} -> (HoppyP.IO M276.QFont)
font arg'1 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M276.QFontConst) =<<
  (font' arg'1')

foregroundBrush :: (QGraphicsSceneValue this) => (this) {- ^ this -} -> (HoppyP.IO M246.QBrush)
foregroundBrush arg'1 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M246.QBrushConst) =<<
  (foregroundBrush' arg'1')

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

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

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

itemAtPointF :: (QGraphicsSceneValue this, M116.QPointFValue arg'2, M336.QTransformValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO M404.QGraphicsItem)
itemAtPointF arg'1 arg'2 arg'3 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M336.withQTransformPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap M404.QGraphicsItem
  (itemAtPointF' arg'1' arg'2' arg'3')

itemAtRaw :: (QGraphicsSceneValue this, M336.QTransformValue arg'4) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (arg'4) -> (HoppyP.IO M404.QGraphicsItem)
itemAtRaw arg'1 arg'2 arg'3 arg'4 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  M336.withQTransformPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap M404.QGraphicsItem
  (itemAtRaw' arg'1' arg'2' arg'3' arg'4')

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

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

mouseGrabberItem :: (QGraphicsSceneValue this) => (this) {- ^ this -} -> (HoppyP.IO M404.QGraphicsItem)
mouseGrabberItem arg'1 =
  withQGraphicsScenePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M404.QGraphicsItem
  (mouseGrabberItem' arg'1')

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

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

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

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

class (QGraphicsSceneConstPtr this, M94.QObjectPtr this) => QGraphicsScenePtr this where
  toQGraphicsScene :: this -> QGraphicsScene

addEllipseRectF :: (QGraphicsScenePtr this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M402.QGraphicsEllipseItem)
addEllipseRectF arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M402.QGraphicsEllipseItem
  (addEllipseRectF' arg'1' arg'2')

addEllipseRectFAll :: (QGraphicsScenePtr this, M124.QRectFValue arg'2, M314.QPenValue arg'3, M246.QBrushValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO M402.QGraphicsEllipseItem)
addEllipseRectFAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M314.withQPenPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M246.withQBrushPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap M402.QGraphicsEllipseItem
  (addEllipseRectFAll' arg'1' arg'2' arg'3' arg'4')

addEllipseRaw :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO M402.QGraphicsEllipseItem)
addEllipseRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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.fmap M402.QGraphicsEllipseItem
  (addEllipseRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

addEllipseRawAll :: (QGraphicsScenePtr this, M314.QPenValue arg'6, M246.QBrushValue arg'7) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (arg'6) -> (arg'7) -> (HoppyP.IO M402.QGraphicsEllipseItem)
addEllipseRawAll arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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' ->
  M314.withQPenPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  M246.withQBrushPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  HoppyP.fmap M402.QGraphicsEllipseItem
  (addEllipseRawAll' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7')

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

addPolygon :: (QGraphicsScenePtr this, M320.QPolygonFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M408.QGraphicsPolygonItem)
addPolygon arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M320.withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M408.QGraphicsPolygonItem
  (addPolygon' arg'1' arg'2')

addPolygonAll :: (QGraphicsScenePtr this, M320.QPolygonFValue arg'2, M314.QPenValue arg'3, M246.QBrushValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO M408.QGraphicsPolygonItem)
addPolygonAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M320.withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M314.withQPenPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M246.withQBrushPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap M408.QGraphicsPolygonItem
  (addPolygonAll' arg'1' arg'2' arg'3' arg'4')

addRect :: (QGraphicsScenePtr this, M124.QRectFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M410.QGraphicsRectItem)
addRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M410.QGraphicsRectItem
  (addRect' arg'1' arg'2')

addRectAll :: (QGraphicsScenePtr this, M124.QRectFValue arg'2, M314.QPenValue arg'3, M246.QBrushValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO M410.QGraphicsRectItem)
addRectAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M124.withQRectFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M314.withQPenPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M246.withQBrushPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  HoppyP.fmap M410.QGraphicsRectItem
  (addRectAll' arg'1' arg'2' arg'3' arg'4')

addRectRaw :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO M410.QGraphicsRectItem)
addRectRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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.fmap M410.QGraphicsRectItem
  (addRectRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

addRectRawAll :: (QGraphicsScenePtr this, M314.QPenValue arg'6, M246.QBrushValue arg'7) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (arg'6) -> (arg'7) -> (HoppyP.IO M410.QGraphicsRectItem)
addRectRawAll arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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' ->
  M314.withQPenPtr arg'6 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'6' ->
  M246.withQBrushPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  HoppyP.fmap M410.QGraphicsRectItem
  (addRectRawAll' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7')

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

setFont :: (QGraphicsScenePtr this, M276.QFontValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFont arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M276.withQFontPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFont' arg'1' arg'2')

invalidate :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
invalidate arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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' ->
  (invalidate' arg'1' arg'2' arg'3' arg'4' arg'5')

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

sendEvent :: (QGraphicsScenePtr this, M404.QGraphicsItemPtr arg'2, M34.QEventPtr arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
sendEvent arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M404.toQGraphicsItem arg'2) $ \arg'2' ->
  HoppyFHR.withCppPtr (M34.toQEvent arg'3) $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (sendEvent' arg'1' arg'2' arg'3')

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

setBackgroundBrush :: (QGraphicsScenePtr this, M246.QBrushValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setBackgroundBrush arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M246.withQBrushPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setBackgroundBrush' arg'1' arg'2')

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

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

setFocusAll :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (M190.QtFocusReason) -> (HoppyP.IO ())
setFocusAll arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setFocusAll' arg'1' arg'2')

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

setFocusItemAll :: (QGraphicsScenePtr this, M404.QGraphicsItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtFocusReason) -> (HoppyP.IO ())
setFocusItemAll arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M404.toQGraphicsItem arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (setFocusItemAll' arg'1' arg'2' arg'3')

setForegroundBrush :: (QGraphicsScenePtr this, M246.QBrushValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setForegroundBrush arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M246.withQBrushPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setForegroundBrush' arg'1' arg'2')

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

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

setSceneRectRaw :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setSceneRectRaw arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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' ->
  (setSceneRectRaw' arg'1' arg'2' arg'3' arg'4' arg'5')

setSelectionAreaTransform :: (QGraphicsScenePtr this, M312.QPainterPathValue arg'2, M336.QTransformValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setSelectionAreaTransform arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M312.withQPainterPathPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M336.withQTransformPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setSelectionAreaTransform' arg'1' arg'2' arg'3')

setSelectionArea :: (QGraphicsScenePtr this, M312.QPainterPathValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setSelectionArea arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGraphicsScene arg'1) $ \arg'1' ->
  M312.withQPainterPathPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setSelectionArea' arg'1' arg'2')

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

update :: (QGraphicsScenePtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
update arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQGraphicsScene 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' ->
  (update' arg'1' arg'2' arg'3' arg'4' arg'5')

data QGraphicsSceneConst =
    QGraphicsSceneConst (HoppyF.Ptr QGraphicsSceneConst)
  | QGraphicsSceneConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGraphicsSceneConst)
  deriving (HoppyP.Show)

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

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

castQGraphicsSceneToConst :: QGraphicsScene -> QGraphicsSceneConst
castQGraphicsSceneToConst (QGraphicsScene ptr') = QGraphicsSceneConst $ HoppyF.castPtr ptr'
castQGraphicsSceneToConst (QGraphicsSceneGc fptr' ptr') = QGraphicsSceneConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QGraphicsSceneConstPtr QGraphicsSceneConst where
  toQGraphicsSceneConst = HoppyP.id

instance M94.QObjectConstPtr QGraphicsSceneConst where
  toQObjectConst (QGraphicsSceneConst ptr') = M94.QObjectConst $ castQGraphicsSceneToQObject ptr'
  toQObjectConst (QGraphicsSceneConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQGraphicsSceneToQObject ptr'

data QGraphicsScene =
    QGraphicsScene (HoppyF.Ptr QGraphicsScene)
  | QGraphicsSceneGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGraphicsScene)
  deriving (HoppyP.Show)

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

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

castQGraphicsSceneToNonconst :: QGraphicsSceneConst -> QGraphicsScene
castQGraphicsSceneToNonconst (QGraphicsSceneConst ptr') = QGraphicsScene $ HoppyF.castPtr ptr'
castQGraphicsSceneToNonconst (QGraphicsSceneConstGc fptr' ptr') = QGraphicsSceneGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QGraphicsSceneConstPtr QGraphicsScene where
  toQGraphicsSceneConst (QGraphicsScene ptr') = QGraphicsSceneConst $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'
  toQGraphicsSceneConst (QGraphicsSceneGc fptr' ptr') = QGraphicsSceneConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'

instance QGraphicsScenePtr QGraphicsScene where
  toQGraphicsScene = HoppyP.id

instance M94.QObjectConstPtr QGraphicsScene where
  toQObjectConst (QGraphicsScene ptr') = M94.QObjectConst $ castQGraphicsSceneToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'
  toQObjectConst (QGraphicsSceneGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQGraphicsSceneToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'

instance M94.QObjectPtr QGraphicsScene where
  toQObject (QGraphicsScene ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQGraphicsSceneToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'
  toQObject (QGraphicsSceneGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQGraphicsSceneToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QGraphicsScene -> HoppyF.Ptr QGraphicsSceneConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QGraphicsScene)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QGraphicsScene
  (newWithParent' arg'1')

newWithRect :: (M124.QRectFValue arg'1) => (arg'1) -> (HoppyP.IO QGraphicsScene)
newWithRect arg'1 =
  M124.withQRectFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGraphicsScene
  (newWithRect' arg'1')

newWithRaw :: (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO QGraphicsScene)
newWithRaw arg'1 arg'2 arg'3 arg'4 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) 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.fmap QGraphicsScene
  (newWithRaw' arg'1' arg'2' arg'3' arg'4')

class QGraphicsSceneSuper a where
  downToQGraphicsScene :: a -> QGraphicsScene

instance QGraphicsSceneSuper M94.QObject where
  downToQGraphicsScene = castQGraphicsSceneToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QGraphicsSceneConst $ castQObjectToQGraphicsScene ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QGraphicsSceneConstGc fptr' $ castQObjectToQGraphicsScene ptr'

class QGraphicsSceneSuperConst a where
  downToQGraphicsSceneConst :: a -> QGraphicsSceneConst

instance QGraphicsSceneSuperConst M94.QObjectConst where
  downToQGraphicsSceneConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QGraphicsSceneConst $ castQObjectToQGraphicsScene ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QGraphicsSceneConstGc fptr' $ castQObjectToQGraphicsScene ptr'

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

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

data QGraphicsSceneItemIndexMethod =
  BspTreeIndex
  | NoIndex
  | UnknownQGraphicsSceneItemIndexMethod (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsSceneItemIndexMethod where
  fromCppEnum BspTreeIndex = 0
  fromCppEnum NoIndex = -1
  fromCppEnum (UnknownQGraphicsSceneItemIndexMethod n) = n
  
  toCppEnum (-1) = NoIndex
  toCppEnum (0) = BspTreeIndex
  toCppEnum n = UnknownQGraphicsSceneItemIndexMethod n

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

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

data QGraphicsSceneSceneLayer =
  ItemLayer
  | BackgroundLayer
  | ForegroundLayer
  | AllLayers
  | UnknownQGraphicsSceneSceneLayer (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGraphicsSceneSceneLayer where
  fromCppEnum ItemLayer = 1
  fromCppEnum BackgroundLayer = 2
  fromCppEnum ForegroundLayer = 4
  fromCppEnum AllLayers = 65535
  fromCppEnum (UnknownQGraphicsSceneSceneLayer n) = n
  
  toCppEnum (1) = ItemLayer
  toCppEnum (2) = BackgroundLayer
  toCppEnum (4) = ForegroundLayer
  toCppEnum (65535) = AllLayers
  toCppEnum n = UnknownQGraphicsSceneSceneLayer n

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

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

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

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

class IsQGraphicsSceneSceneLayers a where
  toQGraphicsSceneSceneLayers :: a -> QGraphicsSceneSceneLayers

instance IsQGraphicsSceneSceneLayers QGraphicsSceneSceneLayers where toQGraphicsSceneSceneLayers = QtahP.id
instance IsQGraphicsSceneSceneLayers QGraphicsSceneSceneLayer where toQGraphicsSceneSceneLayers = QtahFlags.enumToFlags
instance IsQGraphicsSceneSceneLayers (HoppyFC.CInt) where toQGraphicsSceneSceneLayers = QtahFlags.numToFlags

allLayers :: QGraphicsSceneSceneLayers
allLayers = QGraphicsSceneSceneLayers (65535)

backgroundLayer :: QGraphicsSceneSceneLayers
backgroundLayer = QGraphicsSceneSceneLayers (2)

foregroundLayer :: QGraphicsSceneSceneLayers
foregroundLayer = QGraphicsSceneSceneLayers (4)

itemLayer :: QGraphicsSceneSceneLayers
itemLayer = QGraphicsSceneSceneLayers (1)

instance QtahDB.Bits QGraphicsSceneSceneLayers 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