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

module Graphics.UI.Qtah.Generated.Gui.QContextMenuEvent (
  castQContextMenuEventToQInputEvent,
  castQInputEventToQContextMenuEvent,
  castQContextMenuEventToQEvent,
  castQEventToQContextMenuEvent,
  QContextMenuEventValue (..),
  QContextMenuEventConstPtr (..),
  globalPos,
  globalX,
  globalY,
  pos,
  reason,
  x,
  y,
  QContextMenuEventPtr (..),
  QContextMenuEventConst (..),
  castQContextMenuEventToConst,
  QContextMenuEvent (..),
  castQContextMenuEventToNonconst,
  new,
  newWithGlobalPos,
  newWithGlobalPosAndModifiers,
  QContextMenuEventSuper (..),
  QContextMenuEventSuperConst (..),
  QContextMenuEventReason (..),
  ) 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.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.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__QContextMenuEvent_new" new' ::  HoppyFC.CInt -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QContextMenuEvent)
foreign import ccall "genpop__QContextMenuEvent_newWithGlobalPos" newWithGlobalPos' ::  HoppyFC.CInt -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO (HoppyF.Ptr QContextMenuEvent)
foreign import ccall "genpop__QContextMenuEvent_newWithGlobalPosAndModifiers" newWithGlobalPosAndModifiers' ::  HoppyFC.CInt -> HoppyF.Ptr M114.QPointConst -> HoppyF.Ptr M114.QPointConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QContextMenuEvent)
foreign import ccall "genpop__QContextMenuEvent_globalPos" globalPos' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QContextMenuEvent_globalX" globalX' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QContextMenuEvent_globalY" globalY' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QContextMenuEvent_pos" pos' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QContextMenuEvent_reason" reason' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QContextMenuEvent_x" x' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QContextMenuEvent_y" y' ::  HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "gencast__QContextMenuEvent__QInputEvent" castQContextMenuEventToQInputEvent :: HoppyF.Ptr QContextMenuEventConst -> HoppyF.Ptr M294.QInputEventConst
foreign import ccall "gencast__QInputEvent__QContextMenuEvent" castQInputEventToQContextMenuEvent :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr QContextMenuEventConst
foreign import ccall "gencast__QContextMenuEvent__QEvent" castQContextMenuEventToQEvent :: HoppyF.Ptr QContextMenuEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QContextMenuEvent" castQEventToQContextMenuEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QContextMenuEventConst
foreign import ccall "gendel__QContextMenuEvent" delete'QContextMenuEvent :: HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QContextMenuEvent" deletePtr'QContextMenuEvent :: HoppyF.FunPtr (HoppyF.Ptr QContextMenuEventConst -> HoppyP.IO ())

class QContextMenuEventValue a where
  withQContextMenuEventPtr :: a -> (QContextMenuEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QContextMenuEventConstPtr a => QContextMenuEventValue a where
  withQContextMenuEventPtr = HoppyP.flip ($) . toQContextMenuEventConst

class (M294.QInputEventConstPtr this) => QContextMenuEventConstPtr this where
  toQContextMenuEventConst :: this -> QContextMenuEventConst

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

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

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

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

reason :: (QContextMenuEventValue this) => (this) {- ^ this -} -> (HoppyP.IO QContextMenuEventReason)
reason arg'1 =
  withQContextMenuEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (reason' arg'1')

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

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

class (QContextMenuEventConstPtr this, M294.QInputEventPtr this) => QContextMenuEventPtr this where
  toQContextMenuEvent :: this -> QContextMenuEvent

data QContextMenuEventConst =
    QContextMenuEventConst (HoppyF.Ptr QContextMenuEventConst)
  | QContextMenuEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QContextMenuEventConst)
  deriving (HoppyP.Show)

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

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

castQContextMenuEventToConst :: QContextMenuEvent -> QContextMenuEventConst
castQContextMenuEventToConst (QContextMenuEvent ptr') = QContextMenuEventConst $ HoppyF.castPtr ptr'
castQContextMenuEventToConst (QContextMenuEventGc fptr' ptr') = QContextMenuEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QContextMenuEventConstPtr QContextMenuEventConst where
  toQContextMenuEventConst = HoppyP.id

instance M294.QInputEventConstPtr QContextMenuEventConst where
  toQInputEventConst (QContextMenuEventConst ptr') = M294.QInputEventConst $ castQContextMenuEventToQInputEvent ptr'
  toQInputEventConst (QContextMenuEventConstGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQContextMenuEventToQInputEvent ptr'

instance M34.QEventConstPtr QContextMenuEventConst where
  toQEventConst (QContextMenuEventConst ptr') = M34.QEventConst $ castQContextMenuEventToQEvent ptr'
  toQEventConst (QContextMenuEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQContextMenuEventToQEvent ptr'

data QContextMenuEvent =
    QContextMenuEvent (HoppyF.Ptr QContextMenuEvent)
  | QContextMenuEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QContextMenuEvent)
  deriving (HoppyP.Show)

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

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

castQContextMenuEventToNonconst :: QContextMenuEventConst -> QContextMenuEvent
castQContextMenuEventToNonconst (QContextMenuEventConst ptr') = QContextMenuEvent $ HoppyF.castPtr ptr'
castQContextMenuEventToNonconst (QContextMenuEventConstGc fptr' ptr') = QContextMenuEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QContextMenuEventConstPtr QContextMenuEvent where
  toQContextMenuEventConst (QContextMenuEvent ptr') = QContextMenuEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'
  toQContextMenuEventConst (QContextMenuEventGc fptr' ptr') = QContextMenuEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'

instance QContextMenuEventPtr QContextMenuEvent where
  toQContextMenuEvent = HoppyP.id

instance M294.QInputEventConstPtr QContextMenuEvent where
  toQInputEventConst (QContextMenuEvent ptr') = M294.QInputEventConst $ castQContextMenuEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'
  toQInputEventConst (QContextMenuEventGc fptr' ptr') = M294.QInputEventConstGc fptr' $ castQContextMenuEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'

instance M294.QInputEventPtr QContextMenuEvent where
  toQInputEvent (QContextMenuEvent ptr') = M294.QInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQContextMenuEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'
  toQInputEvent (QContextMenuEventGc fptr' ptr') = M294.QInputEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M294.QInputEventConst -> HoppyF.Ptr M294.QInputEvent) $ castQContextMenuEventToQInputEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'

instance M34.QEventConstPtr QContextMenuEvent where
  toQEventConst (QContextMenuEvent ptr') = M34.QEventConst $ castQContextMenuEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'
  toQEventConst (QContextMenuEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQContextMenuEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'

instance M34.QEventPtr QContextMenuEvent where
  toQEvent (QContextMenuEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQContextMenuEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'
  toQEvent (QContextMenuEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQContextMenuEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QContextMenuEvent -> HoppyF.Ptr QContextMenuEventConst) ptr'

new :: (M114.QPointValue arg'2) => (QContextMenuEventReason) -> (arg'2) -> (HoppyP.IO QContextMenuEvent)
new arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  M114.withQPointPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QContextMenuEvent
  (new' arg'1' arg'2')

newWithGlobalPos :: (M114.QPointValue arg'2, M114.QPointValue arg'3) => (QContextMenuEventReason) -> (arg'2) -> (arg'3) -> (HoppyP.IO QContextMenuEvent)
newWithGlobalPos 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 QContextMenuEvent
  (newWithGlobalPos' arg'1' arg'2' arg'3')

newWithGlobalPosAndModifiers :: (M114.QPointValue arg'2, M114.QPointValue arg'3, M190.IsQtKeyboardModifiers arg'4) => (QContextMenuEventReason) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO QContextMenuEvent)
newWithGlobalPosAndModifiers arg'1 arg'2 arg'3 arg'4 =
  (
    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' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'4 >>= \arg'4' ->
  HoppyP.fmap QContextMenuEvent
  (newWithGlobalPosAndModifiers' arg'1' arg'2' arg'3' arg'4')

class QContextMenuEventSuper a where
  downToQContextMenuEvent :: a -> QContextMenuEvent

instance QContextMenuEventSuper M294.QInputEvent where
  downToQContextMenuEvent = castQContextMenuEventToNonconst . cast' . M294.castQInputEventToConst
    where
      cast' (M294.QInputEventConst ptr') = QContextMenuEventConst $ castQInputEventToQContextMenuEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QContextMenuEventConstGc fptr' $ castQInputEventToQContextMenuEvent ptr'
instance QContextMenuEventSuper M34.QEvent where
  downToQContextMenuEvent = castQContextMenuEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QContextMenuEventConst $ castQEventToQContextMenuEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QContextMenuEventConstGc fptr' $ castQEventToQContextMenuEvent ptr'

class QContextMenuEventSuperConst a where
  downToQContextMenuEventConst :: a -> QContextMenuEventConst

instance QContextMenuEventSuperConst M294.QInputEventConst where
  downToQContextMenuEventConst = cast'
    where
      cast' (M294.QInputEventConst ptr') = QContextMenuEventConst $ castQInputEventToQContextMenuEvent ptr'
      cast' (M294.QInputEventConstGc fptr' ptr') = QContextMenuEventConstGc fptr' $ castQInputEventToQContextMenuEvent ptr'
instance QContextMenuEventSuperConst M34.QEventConst where
  downToQContextMenuEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QContextMenuEventConst $ castQEventToQContextMenuEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QContextMenuEventConstGc fptr' $ castQEventToQContextMenuEvent ptr'

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

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

data QContextMenuEventReason =
  Mouse
  | Keyboard
  | Other
  | UnknownQContextMenuEventReason (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QContextMenuEventReason where
  fromCppEnum Mouse = 0
  fromCppEnum Keyboard = 1
  fromCppEnum Other = 2
  fromCppEnum (UnknownQContextMenuEventReason n) = n
  
  toCppEnum (0) = Mouse
  toCppEnum (1) = Keyboard
  toCppEnum (2) = Other
  toCppEnum n = UnknownQContextMenuEventReason n

instance HoppyP.Eq QContextMenuEventReason where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QContextMenuEventReason where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)