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

module Graphics.UI.Qtah.Generated.Gui.QPolygonF (
  castQPolygonFToQVectorQPointF,
  QPolygonFValue (..),
  QPolygonFConstPtr (..),
  boundingRect,
  containsPoint,
  intersected,
  isClosed,
  subtracted,
  toPolygon,
  translatedByRaw,
  translatedByPoint,
  united,
  eQ,
  nE,
  QPolygonFPtr (..),
  swap,
  translateByRaw,
  translateByPoint,
  aSSIGN,
  QPolygonFConst (..),
  castQPolygonFToConst,
  QPolygonF (..),
  castQPolygonFToNonconst,
  new,
  newWithSize,
  newWithPoints,
  newWithPolygon,
  newWithRectangle,
  newCopy,
  QPolygonFSuper (..),
  QPolygonFSuperConst (..),
  ) where

import Control.Monad ((>=>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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.QVector.QPointF as M220
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QPolygon as M318
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QPolygonF_new" new' ::  HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_newWithSize" newWithSize' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_newWithPoints" newWithPoints' ::  HoppyF.Ptr M220.QVectorQPointFConst -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_newWithPolygon" newWithPolygon' ::  HoppyF.Ptr M318.QPolygonConst -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_newWithRectangle" newWithRectangle' ::  HoppyF.Ptr M124.QRectFConst -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_newCopy" newCopy' ::  HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "genpop__QPolygonF_boundingRect" boundingRect' ::  HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr M124.QRectFConst)
foreign import ccall "genpop__QPolygonF_containsPoint" containsPoint' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPolygonF_intersected" intersected' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr QPolygonFConst)
foreign import ccall "genpop__QPolygonF_isClosed" isClosed' ::  HoppyF.Ptr QPolygonFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPolygonF_subtracted" subtracted' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr QPolygonFConst)
foreign import ccall "genpop__QPolygonF_swap" swap' ::  HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonF -> HoppyP.IO ()
foreign import ccall "genpop__QPolygonF_toPolygon" toPolygon' ::  HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr M318.QPolygonConst)
foreign import ccall "genpop__QPolygonF_translateByRaw" translateByRaw' ::  HoppyF.Ptr QPolygonF -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QPolygonF_translateByPoint" translateByPoint' ::  HoppyF.Ptr QPolygonF -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO ()
foreign import ccall "genpop__QPolygonF_translatedByRaw" translatedByRaw' ::  HoppyF.Ptr QPolygonFConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QPolygonFConst)
foreign import ccall "genpop__QPolygonF_translatedByPoint" translatedByPoint' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO (HoppyF.Ptr QPolygonFConst)
foreign import ccall "genpop__QPolygonF_united" united' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr QPolygonFConst)
foreign import ccall "genpop__QPolygonF_EQ" eQ' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPolygonF_NE" nE' ::  HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPolygonF_ASSIGN" aSSIGN' ::  HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst -> HoppyP.IO (HoppyF.Ptr QPolygonF)
foreign import ccall "gencast__QPolygonF__QVectorQPointF" castQPolygonFToQVectorQPointF :: HoppyF.Ptr QPolygonFConst -> HoppyF.Ptr M220.QVectorQPointFConst
foreign import ccall "gendel__QPolygonF" delete'QPolygonF :: HoppyF.Ptr QPolygonFConst -> HoppyP.IO ()
foreign import ccall "&gendel__QPolygonF" deletePtr'QPolygonF :: HoppyF.FunPtr (HoppyF.Ptr QPolygonFConst -> HoppyP.IO ())

class QPolygonFValue a where
  withQPolygonFPtr :: a -> (QPolygonFConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QPolygonFConstPtr a => QPolygonFValue a where
  withQPolygonFPtr = HoppyP.flip ($) . toQPolygonFConst

class (M220.QVectorQPointFConstPtr this) => QPolygonFConstPtr this where
  toQPolygonFConst :: this -> QPolygonFConst

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

containsPoint :: (QPolygonFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtFillRule) -> (HoppyP.IO HoppyP.Bool)
containsPoint arg'1 arg'2 arg'3 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (containsPoint' arg'1' arg'2' arg'3')

intersected :: (QPolygonFValue this, QPolygonFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPolygonF)
intersected arg'1 arg'2 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QPolygonFConst) =<<
  (intersected' arg'1' arg'2')

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

subtracted :: (QPolygonFValue this, QPolygonFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPolygonF)
subtracted arg'1 arg'2 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QPolygonFConst) =<<
  (subtracted' arg'1' arg'2')

toPolygon :: (QPolygonFValue this) => (this) {- ^ this -} -> (HoppyP.IO M318.QPolygon)
toPolygon arg'1 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M318.QPolygonConst) =<<
  (toPolygon' arg'1')

translatedByRaw :: (QPolygonFValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QPolygonF)
translatedByRaw arg'1 arg'2 arg'3 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QPolygonFConst) =<<
  (translatedByRaw' arg'1' arg'2' arg'3')

translatedByPoint :: (QPolygonFValue this, M116.QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPolygonF)
translatedByPoint arg'1 arg'2 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QPolygonFConst) =<<
  (translatedByPoint' arg'1' arg'2')

united :: (QPolygonFValue this, QPolygonFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPolygonF)
united arg'1 arg'2 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QPolygonFConst) =<<
  (united' arg'1' arg'2')

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

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

class (QPolygonFConstPtr this, M220.QVectorQPointFPtr this) => QPolygonFPtr this where
  toQPolygonF :: this -> QPolygonF

swap :: (QPolygonFPtr this, QPolygonFPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPolygonF arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQPolygonF arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

translateByRaw :: (QPolygonFPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
translateByRaw arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQPolygonF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (translateByRaw' arg'1' arg'2' arg'3')

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

aSSIGN :: (QPolygonFPtr this, QPolygonFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPolygonF)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPolygonF arg'1) $ \arg'1' ->
  withQPolygonFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QPolygonF
  (aSSIGN' arg'1' arg'2')

data QPolygonFConst =
    QPolygonFConst (HoppyF.Ptr QPolygonFConst)
  | QPolygonFConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPolygonFConst)
  deriving (HoppyP.Show)

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

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

castQPolygonFToConst :: QPolygonF -> QPolygonFConst
castQPolygonFToConst (QPolygonF ptr') = QPolygonFConst $ HoppyF.castPtr ptr'
castQPolygonFToConst (QPolygonFGc fptr' ptr') = QPolygonFConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QPolygonFConst QPolygonF where copy = newCopy

instance QPolygonFConstPtr QPolygonFConst where
  toQPolygonFConst = HoppyP.id

instance M220.QVectorQPointFConstPtr QPolygonFConst where
  toQVectorQPointFConst (QPolygonFConst ptr') = M220.QVectorQPointFConst $ castQPolygonFToQVectorQPointF ptr'
  toQVectorQPointFConst (QPolygonFConstGc fptr' ptr') = M220.QVectorQPointFConstGc fptr' $ castQPolygonFToQVectorQPointF ptr'

data QPolygonF =
    QPolygonF (HoppyF.Ptr QPolygonF)
  | QPolygonFGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPolygonF)
  deriving (HoppyP.Show)

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

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

castQPolygonFToNonconst :: QPolygonFConst -> QPolygonF
castQPolygonFToNonconst (QPolygonFConst ptr') = QPolygonF $ HoppyF.castPtr ptr'
castQPolygonFToNonconst (QPolygonFConstGc fptr' ptr') = QPolygonFGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QPolygonF QPolygonF where copy = newCopy

instance QPolygonFConstPtr QPolygonF where
  toQPolygonFConst (QPolygonF ptr') = QPolygonFConst $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'
  toQPolygonFConst (QPolygonFGc fptr' ptr') = QPolygonFConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'

instance QPolygonFPtr QPolygonF where
  toQPolygonF = HoppyP.id

instance M220.QVectorQPointFConstPtr QPolygonF where
  toQVectorQPointFConst (QPolygonF ptr') = M220.QVectorQPointFConst $ castQPolygonFToQVectorQPointF $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'
  toQVectorQPointFConst (QPolygonFGc fptr' ptr') = M220.QVectorQPointFConstGc fptr' $ castQPolygonFToQVectorQPointF $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'

instance M220.QVectorQPointFPtr QPolygonF where
  toQVectorQPointF (QPolygonF ptr') = M220.QVectorQPointF $ (HoppyF.castPtr :: HoppyF.Ptr M220.QVectorQPointFConst -> HoppyF.Ptr M220.QVectorQPointF) $ castQPolygonFToQVectorQPointF $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'
  toQVectorQPointF (QPolygonFGc fptr' ptr') = M220.QVectorQPointFGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M220.QVectorQPointFConst -> HoppyF.Ptr M220.QVectorQPointF) $ castQPolygonFToQVectorQPointF $ (HoppyF.castPtr :: HoppyF.Ptr QPolygonF -> HoppyF.Ptr QPolygonFConst) ptr'

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

newWithSize :: (HoppyP.Int) -> (HoppyP.IO QPolygonF)
newWithSize arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QPolygonF
  (newWithSize' arg'1')

newWithPoints :: (M220.QVectorQPointFValue arg'1) => (arg'1) -> (HoppyP.IO QPolygonF)
newWithPoints arg'1 =
  M220.withQVectorQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QPolygonF
  (newWithPoints' arg'1')

newWithPolygon :: (M318.QPolygonValue arg'1) => (arg'1) -> (HoppyP.IO QPolygonF)
newWithPolygon arg'1 =
  M318.withQPolygonPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QPolygonF
  (newWithPolygon' arg'1')

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

newCopy :: (QPolygonFValue arg'1) => (arg'1) -> (HoppyP.IO QPolygonF)
newCopy arg'1 =
  withQPolygonFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QPolygonF
  (newCopy' arg'1')

class QPolygonFSuper a where
  downToQPolygonF :: a -> QPolygonF


class QPolygonFSuperConst a where
  downToQPolygonFConst :: a -> QPolygonFConst


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

instance QPolygonFValue a => HoppyFHR.Assignable QPolygonF a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QPolygonF (QPolygonF) where
  decode = HoppyFHR.decode . toQPolygonFConst

instance HoppyFHR.Decodable QPolygonFConst (QPolygonF) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc