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

module Graphics.UI.Qtah.Generated.Gui.QKeyEvent (
  castQKeyEventToQInputEvent,
  castQInputEventToQKeyEvent,
  castQKeyEventToQEvent,
  castQEventToQKeyEvent,
  QKeyEventValue (..),
  QKeyEventConstPtr (..),
  count,
  isAutoRepeat,
  key,
  modifiers,
  nativeModifiers,
  nativeScanCode,
  nativeVirtualKey,
  text,
  QKeyEventPtr (..),
  QKeyEventConst (..),
  castQKeyEventToConst,
  QKeyEvent (..),
  castQKeyEventToNonconst,
  new,
  newWithText,
  newNative,
  newNativeWithText,
  QKeyEventSuper (..),
  QKeyEventSuperConst (..),
  ) where

import qualified Data.Word as HoppyDW
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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.QString as M142
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__QKeyEvent_new" new' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QKeyEvent)
foreign import ccall "genpop__QKeyEvent_newWithText" newWithText' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CBool -> HoppyFC.CUShort -> HoppyP.IO (HoppyF.Ptr QKeyEvent)
foreign import ccall "genpop__QKeyEvent_newNative" newNative' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyDW.Word32 -> HoppyDW.Word32 -> HoppyDW.Word32 -> HoppyP.IO (HoppyF.Ptr QKeyEvent)
foreign import ccall "genpop__QKeyEvent_newNativeWithText" newNativeWithText' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyDW.Word32 -> HoppyDW.Word32 -> HoppyDW.Word32 -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CBool -> HoppyFC.CUShort -> HoppyP.IO (HoppyF.Ptr QKeyEvent)
foreign import ccall "genpop__QKeyEvent_count" count' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QKeyEvent_isAutoRepeat" isAutoRepeat' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QKeyEvent_key" key' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QKeyEvent_modifiers" modifiers' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QKeyEvent_nativeModifiers" nativeModifiers' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QKeyEvent_nativeScanCode" nativeScanCode' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QKeyEvent_nativeVirtualKey" nativeVirtualKey' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QKeyEvent_text" text' ::  HoppyF.Ptr QKeyEventConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gencast__QKeyEvent__QInputEvent" castQKeyEventToQInputEvent :: HoppyF.Ptr QKeyEventConst -> HoppyF.Ptr M294.QInputEventConst
foreign import ccall "gencast__QInputEvent__QKeyEvent" castQInputEventToQKeyEvent :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr QKeyEventConst
foreign import ccall "gencast__QKeyEvent__QEvent" castQKeyEventToQEvent :: HoppyF.Ptr QKeyEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QKeyEvent" castQEventToQKeyEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QKeyEventConst
foreign import ccall "gendel__QKeyEvent" delete'QKeyEvent :: HoppyF.Ptr QKeyEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QKeyEvent" deletePtr'QKeyEvent :: HoppyF.FunPtr (HoppyF.Ptr QKeyEventConst -> HoppyP.IO ())

class QKeyEventValue a where
  withQKeyEventPtr :: a -> (QKeyEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QKeyEventConstPtr a => QKeyEventValue a where
  withQKeyEventPtr = HoppyP.flip ($) . toQKeyEventConst

class (M294.QInputEventConstPtr this) => QKeyEventConstPtr this where
  toQKeyEventConst :: this -> QKeyEventConst

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

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

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

modifiers :: (QKeyEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtKeyboardModifiers)
modifiers arg'1 =
  withQKeyEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (modifiers' arg'1')

nativeModifiers :: (QKeyEventValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
nativeModifiers arg'1 =
  withQKeyEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (nativeModifiers' arg'1')

nativeScanCode :: (QKeyEventValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
nativeScanCode arg'1 =
  withQKeyEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (nativeScanCode' arg'1')

nativeVirtualKey :: (QKeyEventValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
nativeVirtualKey arg'1 =
  withQKeyEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (nativeVirtualKey' arg'1')

text :: (QKeyEventValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
text arg'1 =
  withQKeyEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (text' arg'1')

class (QKeyEventConstPtr this, M294.QInputEventPtr this) => QKeyEventPtr this where
  toQKeyEvent :: this -> QKeyEvent

data QKeyEventConst =
    QKeyEventConst (HoppyF.Ptr QKeyEventConst)
  | QKeyEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QKeyEventConst)
  deriving (HoppyP.Show)

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

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

castQKeyEventToConst :: QKeyEvent -> QKeyEventConst
castQKeyEventToConst (QKeyEvent ptr') = QKeyEventConst $ HoppyF.castPtr ptr'
castQKeyEventToConst (QKeyEventGc fptr' ptr') = QKeyEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QKeyEventConstPtr QKeyEventConst where
  toQKeyEventConst = HoppyP.id

instance M294.QInputEventConstPtr QKeyEventConst where
  toQInputEventConst (QKeyEventConst ptr') = M294.QInputEventConst $ castQKeyEventToQInputEvent ptr'
  toQInputEventConst (QKeyEventConstGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQKeyEventToQInputEvent ptr'

instance M34.QEventConstPtr QKeyEventConst where
  toQEventConst (QKeyEventConst ptr') = M34.QEventConst $ castQKeyEventToQEvent ptr'
  toQEventConst (QKeyEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQKeyEventToQEvent ptr'

data QKeyEvent =
    QKeyEvent (HoppyF.Ptr QKeyEvent)
  | QKeyEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QKeyEvent)
  deriving (HoppyP.Show)

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

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

castQKeyEventToNonconst :: QKeyEventConst -> QKeyEvent
castQKeyEventToNonconst (QKeyEventConst ptr') = QKeyEvent $ HoppyF.castPtr ptr'
castQKeyEventToNonconst (QKeyEventConstGc fptr' ptr') = QKeyEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QKeyEventConstPtr QKeyEvent where
  toQKeyEventConst (QKeyEvent ptr') = QKeyEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'
  toQKeyEventConst (QKeyEventGc fptr' ptr') = QKeyEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'

instance QKeyEventPtr QKeyEvent where
  toQKeyEvent = HoppyP.id

instance M294.QInputEventConstPtr QKeyEvent where
  toQInputEventConst (QKeyEvent ptr') = M294.QInputEventConst $ castQKeyEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'
  toQInputEventConst (QKeyEventGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQKeyEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'

instance M294.QInputEventPtr QKeyEvent where
  toQInputEvent (QKeyEvent ptr') = M294.QInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQKeyEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'
  toQInputEvent (QKeyEventGc fptr' ptr') = M294.QInputEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQKeyEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'

instance M34.QEventConstPtr QKeyEvent where
  toQEventConst (QKeyEvent ptr') = M34.QEventConst $ castQKeyEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'
  toQEventConst (QKeyEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQKeyEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'

instance M34.QEventPtr QKeyEvent where
  toQEvent (QKeyEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQKeyEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'
  toQEvent (QKeyEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQKeyEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QKeyEvent -> HoppyF.Ptr QKeyEventConst) ptr'

new :: (M190.IsQtKeyboardModifiers arg'3) => (M34.QEventType) -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QKeyEvent)
new arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QKeyEvent
  (new' arg'1' arg'2' arg'3')

newWithText :: (M190.IsQtKeyboardModifiers arg'3, M142.QStringValue arg'4) => (M34.QEventType) -> (HoppyP.Int) -> (arg'3) -> (arg'4) -> (HoppyP.Bool) -> (HoppyFC.CUShort) -> (HoppyP.IO QKeyEvent)
newWithText arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'3 >>= \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'5 >>= \arg'5' ->
  let arg'6' = arg'6 in
  HoppyP.fmap QKeyEvent
  (newWithText' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

newNative :: (M190.IsQtKeyboardModifiers arg'3) => (M34.QEventType) -> (HoppyP.Int) -> (arg'3) -> (HoppyDW.Word32) -> (HoppyDW.Word32) -> (HoppyDW.Word32) -> (HoppyP.IO QKeyEvent)
newNative arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  let arg'5' = arg'5 in
  let arg'6' = arg'6 in
  HoppyP.fmap QKeyEvent
  (newNative' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

newNativeWithText :: (M190.IsQtKeyboardModifiers arg'3, M142.QStringValue arg'7) => (M34.QEventType) -> (HoppyP.Int) -> (arg'3) -> (HoppyDW.Word32) -> (HoppyDW.Word32) -> (HoppyDW.Word32) -> (arg'7) -> (HoppyP.Bool) -> (HoppyFC.CUShort) -> (HoppyP.IO QKeyEvent)
newNativeWithText arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'3 >>= \arg'3' ->
  let arg'4' = arg'4 in
  let arg'5' = arg'5 in
  let arg'6' = arg'6 in
  M142.withQStringPtr arg'7 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'7' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'8 >>= \arg'8' ->
  let arg'9' = arg'9 in
  HoppyP.fmap QKeyEvent
  (newNativeWithText' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

class QKeyEventSuper a where
  downToQKeyEvent :: a -> QKeyEvent

instance QKeyEventSuper M294.QInputEvent where
  downToQKeyEvent = castQKeyEventToNonconst . cast' . M294.castQInputEventToConst
    where
      cast' (M294.QInputEventConst ptr') = QKeyEventConst $ castQInputEventToQKeyEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QKeyEventConstGc fptr' $ castQInputEventToQKeyEvent ptr'
instance QKeyEventSuper M34.QEvent where
  downToQKeyEvent = castQKeyEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QKeyEventConst $ castQEventToQKeyEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QKeyEventConstGc fptr' $ castQEventToQKeyEvent ptr'

class QKeyEventSuperConst a where
  downToQKeyEventConst :: a -> QKeyEventConst

instance QKeyEventSuperConst M294.QInputEventConst where
  downToQKeyEventConst = cast'
    where
      cast' (M294.QInputEventConst ptr') = QKeyEventConst $ castQInputEventToQKeyEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QKeyEventConstGc fptr' $ castQInputEventToQKeyEvent ptr'
instance QKeyEventSuperConst M34.QEventConst where
  downToQKeyEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QKeyEventConst $ castQEventToQKeyEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QKeyEventConstGc fptr' $ castQEventToQKeyEvent ptr'

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

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