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

module Graphics.UI.Qtah.Generated.Gui.QIconDragEvent (
  castQIconDragEventToQEvent,
  castQEventToQIconDragEvent,
  QIconDragEventValue (..),
  QIconDragEventConstPtr (..),
  QIconDragEventPtr (..),
  QIconDragEventConst (..),
  castQIconDragEventToConst,
  QIconDragEvent (..),
  castQIconDragEventToNonconst,
  new,
  QIconDragEventSuper (..),
  QIconDragEventSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QEvent as M34
import Prelude (($), (.), (==))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QIconDragEvent_new" new' ::  HoppyP.IO (HoppyF.Ptr QIconDragEvent)
foreign import ccall "gencast__QIconDragEvent__QEvent" castQIconDragEventToQEvent :: HoppyF.Ptr QIconDragEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QIconDragEvent" castQEventToQIconDragEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QIconDragEventConst
foreign import ccall "gendel__QIconDragEvent" delete'QIconDragEvent :: HoppyF.Ptr QIconDragEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QIconDragEvent" deletePtr'QIconDragEvent :: HoppyF.FunPtr (HoppyF.Ptr QIconDragEventConst -> HoppyP.IO ())

class QIconDragEventValue a where
  withQIconDragEventPtr :: a -> (QIconDragEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QIconDragEventConstPtr a => QIconDragEventValue a where
  withQIconDragEventPtr = HoppyP.flip ($) . toQIconDragEventConst

class (M34.QEventConstPtr this) => QIconDragEventConstPtr this where
  toQIconDragEventConst :: this -> QIconDragEventConst

class (QIconDragEventConstPtr this, M34.QEventPtr this) => QIconDragEventPtr this where
  toQIconDragEvent :: this -> QIconDragEvent

data QIconDragEventConst =
    QIconDragEventConst (HoppyF.Ptr QIconDragEventConst)
  | QIconDragEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QIconDragEventConst)
  deriving (HoppyP.Show)

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

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

castQIconDragEventToConst :: QIconDragEvent -> QIconDragEventConst
castQIconDragEventToConst (QIconDragEvent ptr') = QIconDragEventConst $ HoppyF.castPtr ptr'
castQIconDragEventToConst (QIconDragEventGc fptr' ptr') = QIconDragEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QIconDragEventConstPtr QIconDragEventConst where
  toQIconDragEventConst = HoppyP.id

instance M34.QEventConstPtr QIconDragEventConst where
  toQEventConst (QIconDragEventConst ptr') = M34.QEventConst $ castQIconDragEventToQEvent ptr'
  toQEventConst (QIconDragEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQIconDragEventToQEvent ptr'

data QIconDragEvent =
    QIconDragEvent (HoppyF.Ptr QIconDragEvent)
  | QIconDragEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QIconDragEvent)
  deriving (HoppyP.Show)

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

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

castQIconDragEventToNonconst :: QIconDragEventConst -> QIconDragEvent
castQIconDragEventToNonconst (QIconDragEventConst ptr') = QIconDragEvent $ HoppyF.castPtr ptr'
castQIconDragEventToNonconst (QIconDragEventConstGc fptr' ptr') = QIconDragEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QIconDragEventConstPtr QIconDragEvent where
  toQIconDragEventConst (QIconDragEvent ptr') = QIconDragEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'
  toQIconDragEventConst (QIconDragEventGc fptr' ptr') = QIconDragEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'

instance QIconDragEventPtr QIconDragEvent where
  toQIconDragEvent = HoppyP.id

instance M34.QEventConstPtr QIconDragEvent where
  toQEventConst (QIconDragEvent ptr') = M34.QEventConst $ castQIconDragEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'
  toQEventConst (QIconDragEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQIconDragEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'

instance M34.QEventPtr QIconDragEvent where
  toQEvent (QIconDragEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQIconDragEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'
  toQEvent (QIconDragEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQIconDragEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QIconDragEvent -> HoppyF.Ptr QIconDragEventConst) ptr'

new :: (HoppyP.IO QIconDragEvent)
new =
  HoppyP.fmap QIconDragEvent
  (new')

class QIconDragEventSuper a where
  downToQIconDragEvent :: a -> QIconDragEvent

instance QIconDragEventSuper M34.QEvent where
  downToQIconDragEvent = castQIconDragEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QIconDragEventConst $ castQEventToQIconDragEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QIconDragEventConstGc fptr' $ castQEventToQIconDragEvent ptr'

class QIconDragEventSuperConst a where
  downToQIconDragEventConst :: a -> QIconDragEventConst

instance QIconDragEventSuperConst M34.QEventConst where
  downToQIconDragEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QIconDragEventConst $ castQEventToQIconDragEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QIconDragEventConstGc fptr' $ castQEventToQIconDragEvent ptr'

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

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