QHelpEvent.hs

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

module Graphics.UI.Qtah.Generated.Gui.QHelpEvent (
  castQHelpEventToQEvent,
  castQEventToQHelpEvent,
  QHelpEventValue (..),
  QHelpEventConstPtr (..),
  globalPos,
  globalX,
  globalY,
  pos,
  x,
  y,
  QHelpEventPtr (..),
  QHelpEventConst (..),
  castQHelpEventToConst,
  QHelpEvent (..),
  castQHelpEventToNonconst,
  new,
  QHelpEventSuper (..),
  QHelpEventSuperConst (..),
  ) where

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

foreign import ccall "genpop__QHelpEvent_new" new' ::  HoppyFC.CInt -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QHelpEvent)
foreign import ccall "genpop__QHelpEvent_globalPos" globalPos' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QHelpEvent_globalX" globalX' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QHelpEvent_globalY" globalY' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QHelpEvent_pos" pos' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QHelpEvent_x" x' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QHelpEvent_y" y' ::  HoppyF.Ptr QHelpEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "gencast__QHelpEvent__QEvent" castQHelpEventToQEvent :: HoppyF.Ptr QHelpEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QHelpEvent" castQEventToQHelpEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QHelpEventConst
foreign import ccall "gendel__QHelpEvent" delete'QHelpEvent :: HoppyF.Ptr QHelpEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QHelpEvent" deletePtr'QHelpEvent :: HoppyF.FunPtr (HoppyF.Ptr QHelpEventConst -> HoppyP.IO ())

class QHelpEventValue a where
  withQHelpEventPtr :: a -> (QHelpEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QHelpEventConstPtr a => QHelpEventValue a where
  withQHelpEventPtr = HoppyP.flip ($) . toQHelpEventConst

class (M34.QEventConstPtr this) => QHelpEventConstPtr this where
  toQHelpEventConst :: this -> QHelpEventConst

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

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

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

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

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

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

class (QHelpEventConstPtr this, M34.QEventPtr this) => QHelpEventPtr this where
  toQHelpEvent :: this -> QHelpEvent

data QHelpEventConst =
    QHelpEventConst (HoppyF.Ptr QHelpEventConst)
  | QHelpEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QHelpEventConst)
  deriving (HoppyP.Show)

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

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

castQHelpEventToConst :: QHelpEvent -> QHelpEventConst
castQHelpEventToConst (QHelpEvent ptr') = QHelpEventConst $ HoppyF.castPtr ptr'
castQHelpEventToConst (QHelpEventGc fptr' ptr') = QHelpEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QHelpEventConstPtr QHelpEventConst where
  toQHelpEventConst = HoppyP.id

instance M34.QEventConstPtr QHelpEventConst where
  toQEventConst (QHelpEventConst ptr') = M34.QEventConst $ castQHelpEventToQEvent ptr'
  toQEventConst (QHelpEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQHelpEventToQEvent ptr'

data QHelpEvent =
    QHelpEvent (HoppyF.Ptr QHelpEvent)
  | QHelpEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QHelpEvent)
  deriving (HoppyP.Show)

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

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

castQHelpEventToNonconst :: QHelpEventConst -> QHelpEvent
castQHelpEventToNonconst (QHelpEventConst ptr') = QHelpEvent $ HoppyF.castPtr ptr'
castQHelpEventToNonconst (QHelpEventConstGc fptr' ptr') = QHelpEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QHelpEventConstPtr QHelpEvent where
  toQHelpEventConst (QHelpEvent ptr') = QHelpEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'
  toQHelpEventConst (QHelpEventGc fptr' ptr') = QHelpEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'

instance QHelpEventPtr QHelpEvent where
  toQHelpEvent = HoppyP.id

instance M34.QEventConstPtr QHelpEvent where
  toQEventConst (QHelpEvent ptr') = M34.QEventConst $ castQHelpEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'
  toQEventConst (QHelpEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQHelpEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'

instance M34.QEventPtr QHelpEvent where
  toQEvent (QHelpEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQHelpEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'
  toQEvent (QHelpEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQHelpEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHelpEvent -> HoppyF.Ptr QHelpEventConst) ptr'

new :: (M114.QPointValue arg'2, M114.QPointValue arg'3) => (M34.QEventType) -> (arg'2) -> (arg'3) -> (HoppyP.IO QHelpEvent)
new arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M114.withQPointPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QHelpEvent
  (new' arg'1' arg'2' arg'3')

class QHelpEventSuper a where
  downToQHelpEvent :: a -> QHelpEvent

instance QHelpEventSuper M34.QEvent where
  downToQHelpEvent = castQHelpEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QHelpEventConst $ castQEventToQHelpEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QHelpEventConstGc fptr' $ castQEventToQHelpEvent ptr'

class QHelpEventSuperConst a where
  downToQHelpEventConst :: a -> QHelpEventConst

instance QHelpEventSuperConst M34.QEventConst where
  downToQHelpEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QHelpEventConst $ castQEventToQHelpEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QHelpEventConstGc fptr' $ castQEventToQHelpEvent ptr'

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

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