QDropEvent.hs

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

module Graphics.UI.Qtah.Generated.Gui.QDropEvent (
  castQDropEventToQEvent,
  castQEventToQDropEvent,
  QDropEventValue (..),
  QDropEventConstPtr (..),
  dropAction,
  keyboardModifiers,
  mimeData,
  mouseButtons,
  pos,
  posF,
  possibleActions,
  proposedAction,
  source,
  QDropEventPtr (..),
  acceptProposedAction,
  setDropAction,
  QDropEventConst (..),
  castQDropEventToConst,
  QDropEvent (..),
  castQDropEventToNonconst,
  new,
  newWithType,
  QDropEventSuper (..),
  QDropEventSuperConst (..),
  ) 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.QMimeData as M90
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
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 Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QDropEvent_new" new' ::  HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyF.Ptr M90.QMimeDataConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDropEvent)
foreign import ccall "genpop__QDropEvent_newWithType" newWithType' ::  HoppyF.Ptr M116.QPointFConst -> HoppyFC.CInt -> HoppyF.Ptr M90.QMimeDataConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDropEvent)
foreign import ccall "genpop__QDropEvent_acceptProposedAction" acceptProposedAction' ::  HoppyF.Ptr QDropEvent -> HoppyP.IO ()
foreign import ccall "genpop__QDropEvent_dropAction" dropAction' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDropEvent_setDropAction" setDropAction' ::  HoppyF.Ptr QDropEvent -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QDropEvent_keyboardModifiers" keyboardModifiers' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDropEvent_mimeData" mimeData' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO (HoppyF.Ptr M90.QMimeDataConst)
foreign import ccall "genpop__QDropEvent_mouseButtons" mouseButtons' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDropEvent_pos" pos' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO (HoppyF.Ptr M114.QPointConst)
foreign import ccall "genpop__QDropEvent_posF" posF' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO (HoppyF.Ptr M116.QPointFConst)
foreign import ccall "genpop__QDropEvent_possibleActions" possibleActions' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDropEvent_proposedAction" proposedAction' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QDropEvent_source" source' ::  HoppyF.Ptr QDropEventConst -> HoppyP.IO (HoppyF.Ptr M94.QObject)
foreign import ccall "gencast__QDropEvent__QEvent" castQDropEventToQEvent :: HoppyF.Ptr QDropEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QDropEvent" castQEventToQDropEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QDropEventConst
foreign import ccall "gendel__QDropEvent" delete'QDropEvent :: HoppyF.Ptr QDropEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDropEvent" deletePtr'QDropEvent :: HoppyF.FunPtr (HoppyF.Ptr QDropEventConst -> HoppyP.IO ())

class QDropEventValue a where
  withQDropEventPtr :: a -> (QDropEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDropEventConstPtr a => QDropEventValue a where
  withQDropEventPtr = HoppyP.flip ($) . toQDropEventConst

class (M34.QEventConstPtr this) => QDropEventConstPtr this where
  toQDropEventConst :: this -> QDropEventConst

dropAction :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtDropAction)
dropAction arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (dropAction' arg'1')

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

mimeData :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M90.QMimeDataConst)
mimeData arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M90.QMimeDataConst
  (mimeData' arg'1')

mouseButtons :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtMouseButtons)
mouseButtons arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (mouseButtons' arg'1')

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

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

possibleActions :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtDropActions)
possibleActions arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (possibleActions' arg'1')

proposedAction :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtDropAction)
proposedAction arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (proposedAction' arg'1')

source :: (QDropEventValue this) => (this) {- ^ this -} -> (HoppyP.IO M94.QObject)
source arg'1 =
  withQDropEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M94.QObject
  (source' arg'1')

class (QDropEventConstPtr this, M34.QEventPtr this) => QDropEventPtr this where
  toQDropEvent :: this -> QDropEvent

acceptProposedAction :: (QDropEventPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
acceptProposedAction arg'1 =
  HoppyFHR.withCppPtr (toQDropEvent arg'1) $ \arg'1' ->
  (acceptProposedAction' arg'1')

setDropAction :: (QDropEventPtr this) => (this) {- ^ this -} -> (M190.QtDropAction) -> (HoppyP.IO ())
setDropAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDropEvent arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setDropAction' arg'1' arg'2')

data QDropEventConst =
    QDropEventConst (HoppyF.Ptr QDropEventConst)
  | QDropEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDropEventConst)
  deriving (HoppyP.Show)

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

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

castQDropEventToConst :: QDropEvent -> QDropEventConst
castQDropEventToConst (QDropEvent ptr') = QDropEventConst $ HoppyF.castPtr ptr'
castQDropEventToConst (QDropEventGc fptr' ptr') = QDropEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDropEventConstPtr QDropEventConst where
  toQDropEventConst = HoppyP.id

instance M34.QEventConstPtr QDropEventConst where
  toQEventConst (QDropEventConst ptr') = M34.QEventConst $ castQDropEventToQEvent ptr'
  toQEventConst (QDropEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQDropEventToQEvent ptr'

data QDropEvent =
    QDropEvent (HoppyF.Ptr QDropEvent)
  | QDropEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDropEvent)
  deriving (HoppyP.Show)

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

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

castQDropEventToNonconst :: QDropEventConst -> QDropEvent
castQDropEventToNonconst (QDropEventConst ptr') = QDropEvent $ HoppyF.castPtr ptr'
castQDropEventToNonconst (QDropEventConstGc fptr' ptr') = QDropEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDropEventConstPtr QDropEvent where
  toQDropEventConst (QDropEvent ptr') = QDropEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'
  toQDropEventConst (QDropEventGc fptr' ptr') = QDropEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'

instance QDropEventPtr QDropEvent where
  toQDropEvent = HoppyP.id

instance M34.QEventConstPtr QDropEvent where
  toQEventConst (QDropEvent ptr') = M34.QEventConst $ castQDropEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'
  toQEventConst (QDropEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQDropEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'

instance M34.QEventPtr QDropEvent where
  toQEvent (QDropEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQDropEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'
  toQEvent (QDropEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQDropEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDropEvent -> HoppyF.Ptr QDropEventConst) ptr'

new :: (M116.QPointFValue arg'1, M190.IsQtDropActions arg'2, M90.QMimeDataValue arg'3, M190.IsQtMouseButtons arg'4, M190.IsQtKeyboardModifiers arg'5) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (HoppyP.IO QDropEvent)
new arg'1 arg'2 arg'3 arg'4 arg'5 =
  M116.withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtDropActions
  ) arg'2 >>= \arg'2' ->
  M90.withQMimeDataPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtMouseButtons
  ) arg'4 >>= \arg'4' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'5 >>= \arg'5' ->
  HoppyP.fmap QDropEvent
  (new' arg'1' arg'2' arg'3' arg'4' arg'5')

newWithType :: (M116.QPointFValue arg'1, M190.IsQtDropActions arg'2, M90.QMimeDataValue arg'3, M190.IsQtMouseButtons arg'4, M190.IsQtKeyboardModifiers arg'5) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (M34.QEventType) -> (HoppyP.IO QDropEvent)
newWithType arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  M116.withQPointFPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtDropActions
  ) arg'2 >>= \arg'2' ->
  M90.withQMimeDataPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtMouseButtons
  ) arg'4 >>= \arg'4' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtKeyboardModifiers
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'6 >>= \arg'6' ->
  HoppyP.fmap QDropEvent
  (newWithType' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

class QDropEventSuper a where
  downToQDropEvent :: a -> QDropEvent

instance QDropEventSuper M34.QEvent where
  downToQDropEvent = castQDropEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QDropEventConst $ castQEventToQDropEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QDropEventConstGc fptr' $ castQEventToQDropEvent ptr'

class QDropEventSuperConst a where
  downToQDropEventConst :: a -> QDropEventConst

instance QDropEventSuperConst M34.QEventConst where
  downToQDropEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QDropEventConst $ castQEventToQDropEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QDropEventConstGc fptr' $ castQEventToQDropEvent ptr'

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

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