{-# LANGUAGE CPP, FlexibleContexts, FlexibleInstances, GeneralizedNewtypeDeriving, MultiParamTypeClasses, ScopedTypeVariables, TypeSynonymInstances, UndecidableInstances #-}
#if !MIN_VERSION_base(4,8,0)
{-# LANGUAGE OverlappingInstances #-}
#endif

---------- GENERATED FILE, EDITS WILL BE LOST ----------

module Graphics.UI.Qtah.Generated.Internal.EventListener (
  castEventListenerToQObject,
  castQObjectToEventListener,
  EventListenerValue (..),
  EventListenerConstPtr (..),
  EventListenerPtr (..),
  doNotNotifyOnDelete,
  EventListenerConst (..),
  castEventListenerToConst,
  EventListener (..),
  castEventListenerToNonconst,
  new,
  EventListenerSuper (..),
  EventListenerSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QEvent as M16
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M30
import qualified Graphics.UI.Qtah.Internal.Callback as M156
import Prelude (($), (.), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__EventListener_new" new' ::  HoppyF.Ptr M30.QObject -> HoppyFHR.CCallback (HoppyF.Ptr M30.QObject -> HoppyF.Ptr M16.QEvent -> HoppyP.IO HoppyFHR.CBool) -> HoppyFHR.CCallback (HoppyP.IO ()) -> HoppyP.IO (HoppyF.Ptr EventListener)
foreign import ccall "genpop__EventListener_doNotNotifyOnDelete" doNotNotifyOnDelete' ::  HoppyF.Ptr EventListener -> HoppyP.IO ()
foreign import ccall "gencast__EventListener__QObject" castEventListenerToQObject :: HoppyF.Ptr EventListenerConst -> HoppyF.Ptr M30.QObjectConst
foreign import ccall "gencast__QObject__EventListener" castQObjectToEventListener :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr EventListenerConst
foreign import ccall "gendel__EventListener" delete'EventListener :: HoppyF.Ptr EventListenerConst -> HoppyP.IO ()
foreign import ccall "&gendel__EventListener" deletePtr'EventListener :: HoppyF.FunPtr (HoppyF.Ptr EventListenerConst -> HoppyP.IO ())

class EventListenerValue a where
  withEventListenerPtr :: a -> (EventListenerConst -> HoppyP.IO b) -> HoppyP.IO b

#if MIN_VERSION_base(4,8,0)
instance {-# OVERLAPPABLE #-} EventListenerConstPtr a => EventListenerValue a where
#else
instance EventListenerConstPtr a => EventListenerValue a where
#endif
  withEventListenerPtr = HoppyP.flip ($) . toEventListenerConst

class (M30.QObjectConstPtr this) => EventListenerConstPtr this where
  toEventListenerConst :: this -> EventListenerConst

class (EventListenerConstPtr this, M30.QObjectPtr this) => EventListenerPtr this where
  toEventListener :: this -> EventListener

doNotNotifyOnDelete :: (EventListenerPtr arg'1) => arg'1 -> HoppyP.IO ()
doNotNotifyOnDelete arg'1 =
  HoppyFHR.withCppPtr (toEventListener arg'1) $ \arg'1' ->
  (doNotNotifyOnDelete' arg'1')

data EventListenerConst =
    EventListenerConst (HoppyF.Ptr EventListenerConst)
  | EventListenerConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr EventListenerConst)
  deriving (HoppyP.Show)

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

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

castEventListenerToConst :: EventListener -> EventListenerConst
castEventListenerToConst (EventListener ptr') = EventListenerConst $ HoppyF.castPtr ptr'
castEventListenerToConst (EventListenerGc fptr' ptr') = EventListenerConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance EventListenerConstPtr EventListenerConst where
  toEventListenerConst = HoppyP.id

instance M30.QObjectConstPtr EventListenerConst where
  toQObjectConst (EventListenerConst ptr') = M30.QObjectConst $ castEventListenerToQObject ptr'
  toQObjectConst (EventListenerConstGc fptr' ptr') = M30.QObjectConstGc fptr' $ castEventListenerToQObject ptr'

data EventListener =
    EventListener (HoppyF.Ptr EventListener)
  | EventListenerGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr EventListener)
  deriving (HoppyP.Show)

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

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

castEventListenerToNonconst :: EventListenerConst -> EventListener
castEventListenerToNonconst (EventListenerConst ptr') = EventListener $ HoppyF.castPtr ptr'
castEventListenerToNonconst (EventListenerConstGc fptr' ptr') = EventListenerGc fptr' $ HoppyF.castPtr ptr'

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

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

instance EventListenerConstPtr EventListener where
  toEventListenerConst (EventListener ptr') = EventListenerConst $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'
  toEventListenerConst (EventListenerGc fptr' ptr') = EventListenerConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'

instance EventListenerPtr EventListener where
  toEventListener = HoppyP.id

instance M30.QObjectConstPtr EventListener where
  toQObjectConst (EventListener ptr') = M30.QObjectConst $ castEventListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'
  toQObjectConst (EventListenerGc fptr' ptr') = M30.QObjectConstGc fptr' $ castEventListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'

instance M30.QObjectPtr EventListener where
  toQObject (EventListener ptr') = M30.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr M30.QObject) $ castEventListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'
  toQObject (EventListenerGc fptr' ptr') = M30.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M30.QObjectConst -> HoppyF.Ptr M30.QObject) $ castEventListenerToQObject $ (HoppyF.castPtr :: HoppyF.Ptr EventListener -> HoppyF.Ptr EventListenerConst) ptr'

new :: (M30.QObjectPtr arg'1) => arg'1 -> (M30.QObject -> M16.QEvent -> HoppyP.IO HoppyP.Bool) -> HoppyP.IO () -> HoppyP.IO EventListener
new arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (M30.toQObject arg'1) $ \arg'1' ->
  M156.callbackPtrQObjectPtrQEventBool_new arg'2 >>= \arg'2' ->
  M156.callbackVoid_new arg'3 >>= \arg'3' ->
  HoppyP.fmap EventListener
  (new' arg'1' arg'2' arg'3')

class EventListenerSuper a where
  downToEventListener :: a -> EventListener

instance EventListenerSuper M30.QObject where
  downToEventListener = castEventListenerToNonconst . cast' . M30.castQObjectToConst
    where
      cast' (M30.QObjectConst ptr') = EventListenerConst $ castQObjectToEventListener ptr'
      cast' (M30.QObjectConstGc fptr' ptr') = EventListenerConstGc fptr' $ castQObjectToEventListener ptr'

class EventListenerSuperConst a where
  downToEventListenerConst :: a -> EventListenerConst

instance EventListenerSuperConst M30.QObjectConst where
  downToEventListenerConst = cast'
    where
      cast' (M30.QObjectConst ptr') = EventListenerConst $ castQObjectToEventListener ptr'
      cast' (M30.QObjectConstGc fptr' ptr') = EventListenerConstGc fptr' $ castQObjectToEventListener ptr'

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

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