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

module Graphics.UI.Qtah.Generated.Core.QPointF (
  QPointFValue (..),
  QPointFConstPtr (..),
  isNull,
  manhattanLength,
  toPoint,
  x,
  y,
  eQ,
  nE,
  QPointFPtr (..),
  setX,
  setY,
  aDDA,
  sUBA,
  mULA,
  dIVA,
  aSSIGN,
  dotProduct,
  QPointFConst (..),
  castQPointFToConst,
  QPointF (..),
  castQPointFToNonconst,
  newNull,
  new,
  newFromPoint,
  newCopy,
  QPointFSuper (..),
  QPointFSuperConst (..),
  ) where

import Control.Applicative ((<$>), (<*>))
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HPoint as HPoint
import qualified Graphics.UI.Qtah.Core.HPointF as HPointF
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import Prelude (($), (.), (/=), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QPointF_newNull" newNull' ::  HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_new" new' ::  HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_newFromPoint" newFromPoint' ::  HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_newCopy" newCopy' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_dotProduct" dotProduct' ::  HoppyF.Ptr QPointFConst -> HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QPointF_isNull" isNull' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPointF_manhattanLength" manhattanLength' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QPointF_toPoint" toPoint' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QPointF_x" x' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QPointF_setX" setX' ::  HoppyF.Ptr QPointF -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QPointF_y" y' ::  HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QPointF_setY" setY' ::  HoppyF.Ptr QPointF -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QPointF_ADDA" aDDA' ::  HoppyF.Ptr QPointF -> HoppyF.Ptr QPointFConst -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_SUBA" sUBA' ::  HoppyF.Ptr QPointF -> HoppyF.Ptr QPointFConst -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_MULA" mULA' ::  HoppyF.Ptr QPointF -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_DIVA" dIVA' ::  HoppyF.Ptr QPointF -> HoppyFC.CDouble -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "genpop__QPointF_EQ" eQ' ::  HoppyF.Ptr QPointFConst -> HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPointF_NE" nE' ::  HoppyF.Ptr QPointFConst -> HoppyF.Ptr QPointFConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QPointF_ASSIGN" aSSIGN' ::  HoppyF.Ptr QPointF -> HoppyF.Ptr QPointFConst -> HoppyP.IO (HoppyF.Ptr QPointF)
foreign import ccall "gendel__QPointF" delete'QPointF :: HoppyF.Ptr QPointFConst -> HoppyP.IO ()
foreign import ccall "&gendel__QPointF" deletePtr'QPointF :: HoppyF.FunPtr (HoppyF.Ptr QPointFConst -> HoppyP.IO ())

class QPointFValue a where
  withQPointFPtr :: a -> (QPointFConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QPointFConstPtr a => QPointFValue a where
  withQPointFPtr = HoppyP.flip ($) . toQPointFConst

instance {-# OVERLAPPING #-} QPointFValue (HPointF.HPointF) where
  withQPointFPtr = HoppyFHR.withCppObj

class (HoppyFHR.CppPtr this) => QPointFConstPtr this where
  toQPointFConst :: this -> QPointFConst

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

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

toPoint :: (QPointFValue this) => (this) {- ^ this -} -> (HoppyP.IO HPoint.HPoint)
toPoint arg'1 =
  withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M114.QPointConst) =<<
  (toPoint' arg'1')

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

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

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

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

class (QPointFConstPtr this) => QPointFPtr this where
  toQPointF :: this -> QPointF

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

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

aDDA :: (QPointFPtr this, QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPointF)
aDDA arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPointF arg'1) $ \arg'1' ->
  withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QPointF
  (aDDA' arg'1' arg'2')

sUBA :: (QPointFPtr this, QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPointF)
sUBA arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPointF arg'1) $ \arg'1' ->
  withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QPointF
  (sUBA' arg'1' arg'2')

mULA :: (QPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO QPointF)
mULA arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QPointF
  (mULA' arg'1' arg'2')

dIVA :: (QPointFPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO QPointF)
dIVA arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPointF arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QPointF
  (dIVA' arg'1' arg'2')

aSSIGN :: (QPointFPtr this, QPointFValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QPointF)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPointF arg'1) $ \arg'1' ->
  withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QPointF
  (aSSIGN' arg'1' arg'2')

dotProduct :: (QPointFValue arg'1, QPointFValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Double)
dotProduct arg'1 arg'2 =
  withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (dotProduct' arg'1' arg'2')

data QPointFConst =
    QPointFConst (HoppyF.Ptr QPointFConst)
  | QPointFConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPointFConst)
  deriving (HoppyP.Show)

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

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

castQPointFToConst :: QPointF -> QPointFConst
castQPointFToConst (QPointF ptr') = QPointFConst $ HoppyF.castPtr ptr'
castQPointFToConst (QPointFGc fptr' ptr') = QPointFConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QPointFConst QPointF where copy = newCopy

instance QPointFConstPtr QPointFConst where
  toQPointFConst = HoppyP.id

data QPointF =
    QPointF (HoppyF.Ptr QPointF)
  | QPointFGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPointF)
  deriving (HoppyP.Show)

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

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

castQPointFToNonconst :: QPointFConst -> QPointF
castQPointFToNonconst (QPointFConst ptr') = QPointF $ HoppyF.castPtr ptr'
castQPointFToNonconst (QPointFConstGc fptr' ptr') = QPointFGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QPointF QPointF where copy = newCopy

instance QPointFConstPtr QPointF where
  toQPointFConst (QPointF ptr') = QPointFConst $ (HoppyF.castPtr :: HoppyF.Ptr QPointF -> HoppyF.Ptr QPointFConst) ptr'
  toQPointFConst (QPointFGc fptr' ptr') = QPointFConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QPointF -> HoppyF.Ptr QPointFConst) ptr'

instance QPointFPtr QPointF where
  toQPointF = HoppyP.id

newNull :: (HoppyP.IO QPointF)
newNull =
  HoppyP.fmap QPointF
  (newNull')

new :: (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO QPointF)
new arg'1 arg'2 =
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QPointF
  (new' arg'1' arg'2')

newFromPoint :: (M114.QPointValue arg'1) => (arg'1) -> (HoppyP.IO QPointF)
newFromPoint arg'1 =
  M114.withQPointPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QPointF
  (newFromPoint' arg'1')

newCopy :: (QPointFValue arg'1) => (arg'1) -> (HoppyP.IO QPointF)
newCopy arg'1 =
  withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QPointF
  (newCopy' arg'1')

class QPointFSuper a where
  downToQPointF :: a -> QPointF


class QPointFSuperConst a where
  downToQPointFConst :: a -> QPointFConst


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

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

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

instance HoppyFHR.Encodable QPointF (HPointF.HPointF) where
  encode =
    new <$> HPointF.x <*> HPointF.y

instance HoppyFHR.Encodable QPointFConst (HPointF.HPointF) where
  encode = HoppyP.fmap (toQPointFConst) . HoppyFHR.encodeAs (HoppyP.undefined :: QPointF)

instance HoppyFHR.Decodable QPointF (HPointF.HPointF) where
  decode = HoppyFHR.decode . toQPointFConst

instance HoppyFHR.Decodable QPointFConst (HPointF.HPointF) where
  decode =
    \q -> HPointF.HPointF <$> x q <*> y q