QHoverEvent.hs

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

module Graphics.UI.Qtah.Generated.Gui.QHoverEvent (
  castQHoverEventToQInputEvent,
  castQInputEventToQHoverEvent,
  castQHoverEventToQEvent,
  castQEventToQHoverEvent,
  QHoverEventValue (..),
  QHoverEventConstPtr (..),
  oldPos,
  oldPosF,
  pos,
  posF,
  QHoverEventPtr (..),
  QHoverEventConst (..),
  castQHoverEventToConst,
  QHoverEvent (..),
  castQHoverEventToNonconst,
  new,
  newWithModifiers,
  QHoverEventSuper (..),
  QHoverEventSuperConst (..),
  ) 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.Core.HPointF as HPointF
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.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QPointF as M116
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QInputEvent as M294
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QHoverEvent_new" new' ::  HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyP.IO (HoppyF.Ptr QHoverEvent)
foreign import ccall "genpop__QHoverEvent_newWithModifiers" newWithModifiers' ::  HoppyFC.CInt -> HoppyF.Ptr M116.QPointFConst -> HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QHoverEvent)
foreign import ccall "genpop__QHoverEvent_oldPos" oldPos' ::  HoppyF.Ptr QHoverEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QHoverEvent_oldPosF" oldPosF' ::  HoppyF.Ptr QHoverEventConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QHoverEvent_pos" pos' ::  HoppyF.Ptr QHoverEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QHoverEvent_posF" posF' ::  HoppyF.Ptr QHoverEventConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "gencast__QHoverEvent__QInputEvent" castQHoverEventToQInputEvent :: HoppyF.Ptr QHoverEventConst -> HoppyF.Ptr M294.QInputEventConst
foreign import ccall "gencast__QInputEvent__QHoverEvent" castQInputEventToQHoverEvent :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr QHoverEventConst
foreign import ccall "gencast__QHoverEvent__QEvent" castQHoverEventToQEvent :: HoppyF.Ptr QHoverEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QHoverEvent" castQEventToQHoverEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QHoverEventConst
foreign import ccall "gendel__QHoverEvent" delete'QHoverEvent :: HoppyF.Ptr QHoverEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QHoverEvent" deletePtr'QHoverEvent :: HoppyF.FunPtr (HoppyF.Ptr QHoverEventConst -> HoppyP.IO ())

class QHoverEventValue a where
  withQHoverEventPtr :: a -> (QHoverEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QHoverEventConstPtr a => QHoverEventValue a where
  withQHoverEventPtr = HoppyP.flip ($) . toQHoverEventConst

class (M294.QInputEventConstPtr this) => QHoverEventConstPtr this where
  toQHoverEventConst :: this -> QHoverEventConst

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

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

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

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

class (QHoverEventConstPtr this, M294.QInputEventPtr this) => QHoverEventPtr this where
  toQHoverEvent :: this -> QHoverEvent

data QHoverEventConst =
    QHoverEventConst (HoppyF.Ptr QHoverEventConst)
  | QHoverEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QHoverEventConst)
  deriving (HoppyP.Show)

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

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

castQHoverEventToConst :: QHoverEvent -> QHoverEventConst
castQHoverEventToConst (QHoverEvent ptr') = QHoverEventConst $ HoppyF.castPtr ptr'
castQHoverEventToConst (QHoverEventGc fptr' ptr') = QHoverEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QHoverEventConstPtr QHoverEventConst where
  toQHoverEventConst = HoppyP.id

instance M294.QInputEventConstPtr QHoverEventConst where
  toQInputEventConst (QHoverEventConst ptr') = M294.QInputEventConst $ castQHoverEventToQInputEvent ptr'
  toQInputEventConst (QHoverEventConstGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQHoverEventToQInputEvent ptr'

instance M34.QEventConstPtr QHoverEventConst where
  toQEventConst (QHoverEventConst ptr') = M34.QEventConst $ castQHoverEventToQEvent ptr'
  toQEventConst (QHoverEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQHoverEventToQEvent ptr'

data QHoverEvent =
    QHoverEvent (HoppyF.Ptr QHoverEvent)
  | QHoverEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QHoverEvent)
  deriving (HoppyP.Show)

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

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

castQHoverEventToNonconst :: QHoverEventConst -> QHoverEvent
castQHoverEventToNonconst (QHoverEventConst ptr') = QHoverEvent $ HoppyF.castPtr ptr'
castQHoverEventToNonconst (QHoverEventConstGc fptr' ptr') = QHoverEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QHoverEventConstPtr QHoverEvent where
  toQHoverEventConst (QHoverEvent ptr') = QHoverEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'
  toQHoverEventConst (QHoverEventGc fptr' ptr') = QHoverEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'

instance QHoverEventPtr QHoverEvent where
  toQHoverEvent = HoppyP.id

instance M294.QInputEventConstPtr QHoverEvent where
  toQInputEventConst (QHoverEvent ptr') = M294.QInputEventConst $ castQHoverEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'
  toQInputEventConst (QHoverEventGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQHoverEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'

instance M294.QInputEventPtr QHoverEvent where
  toQInputEvent (QHoverEvent ptr') = M294.QInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQHoverEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'
  toQInputEvent (QHoverEventGc fptr' ptr') = M294.QInputEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQHoverEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'

instance M34.QEventConstPtr QHoverEvent where
  toQEventConst (QHoverEvent ptr') = M34.QEventConst $ castQHoverEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'
  toQEventConst (QHoverEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQHoverEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'

instance M34.QEventPtr QHoverEvent where
  toQEvent (QHoverEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQHoverEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'
  toQEvent (QHoverEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQHoverEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QHoverEvent -> HoppyF.Ptr QHoverEventConst) ptr'

new :: (M116.QPointFValue arg'2, M116.QPointFValue arg'3) => (M34.QEventType) -> (arg'2) -> (arg'3) -> (HoppyP.IO QHoverEvent)
new arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M116.withQPointFPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap QHoverEvent
  (new' arg'1' arg'2' arg'3')

newWithModifiers :: (M116.QPointFValue arg'2, M116.QPointFValue arg'3, M190.IsQtKeyboardModifiers arg'4) => (M34.QEventType) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO QHoverEvent)
newWithModifiers arg'1 arg'2 arg'3 arg'4 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M116.withQPointFPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M116.withQPointFPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QHoverEvent
  (newWithModifiers' arg'1' arg'2' arg'3' arg'4')

class QHoverEventSuper a where
  downToQHoverEvent :: a -> QHoverEvent

instance QHoverEventSuper M294.QInputEvent where
  downToQHoverEvent = castQHoverEventToNonconst . cast' . M294.castQInputEventToConst
    where
      cast' (M294.QInputEventConst ptr') = QHoverEventConst $ castQInputEventToQHoverEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QHoverEventConstGc fptr' $ castQInputEventToQHoverEvent ptr'
instance QHoverEventSuper M34.QEvent where
  downToQHoverEvent = castQHoverEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QHoverEventConst $ castQEventToQHoverEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QHoverEventConstGc fptr' $ castQEventToQHoverEvent ptr'

class QHoverEventSuperConst a where
  downToQHoverEventConst :: a -> QHoverEventConst

instance QHoverEventSuperConst M294.QInputEventConst where
  downToQHoverEventConst = cast'
    where
      cast' (M294.QInputEventConst ptr') = QHoverEventConst $ castQInputEventToQHoverEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QHoverEventConstGc fptr' $ castQInputEventToQHoverEvent ptr'
instance QHoverEventSuperConst M34.QEventConst where
  downToQHoverEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QHoverEventConst $ castQEventToQHoverEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QHoverEventConstGc fptr' $ castQEventToQHoverEvent ptr'

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

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