QDragMoveEvent.hs

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

module Graphics.UI.Qtah.Generated.Gui.QDragMoveEvent (
  castQDragMoveEventToQDropEvent,
  castQDropEventToQDragMoveEvent,
  castQDragMoveEventToQEvent,
  castQEventToQDragMoveEvent,
  QDragMoveEventValue (..),
  QDragMoveEventConstPtr (..),
  answerRect,
  QDragMoveEventPtr (..),
  accept,
  acceptWithRect,
  ignore,
  ignoreWithRect,
  QDragMoveEventConst (..),
  castQDragMoveEventToConst,
  QDragMoveEvent (..),
  castQDragMoveEventToNonconst,
  new,
  newWithType,
  QDragMoveEventSuper (..),
  QDragMoveEventSuperConst (..),
  ) 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.HRect as HRect
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.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QRect as M122
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QDropEvent as M266
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QDragMoveEvent_new" new' ::  HoppyF.Ptr M114.QPointConst -> HoppyFC.CInt -> HoppyF.Ptr M90.QMimeDataConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDragMoveEvent)
foreign import ccall "genpop__QDragMoveEvent_newWithType" newWithType' ::  HoppyF.Ptr M114.QPointConst -> HoppyFC.CInt -> HoppyF.Ptr M90.QMimeDataConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QDragMoveEvent)
foreign import ccall "genpop__QDragMoveEvent_accept" accept' ::  HoppyF.Ptr QDragMoveEvent -> HoppyP.IO ()
foreign import ccall "genpop__QDragMoveEvent_acceptWithRect" acceptWithRect' ::  HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QDragMoveEvent_answerRect" answerRect' ::  HoppyF.Ptr QDragMoveEventConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QDragMoveEvent_ignore" ignore' ::  HoppyF.Ptr QDragMoveEvent -> HoppyP.IO ()
foreign import ccall "genpop__QDragMoveEvent_ignoreWithRect" ignoreWithRect' ::  HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "gencast__QDragMoveEvent__QDropEvent" castQDragMoveEventToQDropEvent :: HoppyF.Ptr QDragMoveEventConst -> HoppyF.Ptr M266.QDropEventConst
foreign import ccall "gencast__QDropEvent__QDragMoveEvent" castQDropEventToQDragMoveEvent :: HoppyF.Ptr M266.QDropEventConst -> HoppyF.Ptr QDragMoveEventConst
foreign import ccall "gencast__QDragMoveEvent__QEvent" castQDragMoveEventToQEvent :: HoppyF.Ptr QDragMoveEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QDragMoveEvent" castQEventToQDragMoveEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QDragMoveEventConst
foreign import ccall "gendel__QDragMoveEvent" delete'QDragMoveEvent :: HoppyF.Ptr QDragMoveEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QDragMoveEvent" deletePtr'QDragMoveEvent :: HoppyF.FunPtr (HoppyF.Ptr QDragMoveEventConst -> HoppyP.IO ())

class QDragMoveEventValue a where
  withQDragMoveEventPtr :: a -> (QDragMoveEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QDragMoveEventConstPtr a => QDragMoveEventValue a where
  withQDragMoveEventPtr = HoppyP.flip ($) . toQDragMoveEventConst

class (M266.QDropEventConstPtr this) => QDragMoveEventConstPtr this where
  toQDragMoveEventConst :: this -> QDragMoveEventConst

answerRect :: (QDragMoveEventValue this) => (this) {- ^ this -} -> (HoppyP.IO HRect.HRect)
answerRect arg'1 =
  withQDragMoveEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M122.QRectConst) =<<
  (answerRect' arg'1')

class (QDragMoveEventConstPtr this, M266.QDropEventPtr this) => QDragMoveEventPtr this where
  toQDragMoveEvent :: this -> QDragMoveEvent

accept :: (QDragMoveEventPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
accept arg'1 =
  HoppyFHR.withCppPtr (toQDragMoveEvent arg'1) $ \arg'1' ->
  (accept' arg'1')

acceptWithRect :: (QDragMoveEventPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
acceptWithRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDragMoveEvent arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (acceptWithRect' arg'1' arg'2')

ignore :: (QDragMoveEventPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
ignore arg'1 =
  HoppyFHR.withCppPtr (toQDragMoveEvent arg'1) $ \arg'1' ->
  (ignore' arg'1')

ignoreWithRect :: (QDragMoveEventPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
ignoreWithRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQDragMoveEvent arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (ignoreWithRect' arg'1' arg'2')

data QDragMoveEventConst =
    QDragMoveEventConst (HoppyF.Ptr QDragMoveEventConst)
  | QDragMoveEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDragMoveEventConst)
  deriving (HoppyP.Show)

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

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

castQDragMoveEventToConst :: QDragMoveEvent -> QDragMoveEventConst
castQDragMoveEventToConst (QDragMoveEvent ptr') = QDragMoveEventConst $ HoppyF.castPtr ptr'
castQDragMoveEventToConst (QDragMoveEventGc fptr' ptr') = QDragMoveEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDragMoveEventConstPtr QDragMoveEventConst where
  toQDragMoveEventConst = HoppyP.id

instance M266.QDropEventConstPtr QDragMoveEventConst where
  toQDropEventConst (QDragMoveEventConst ptr') = M266.QDropEventConst $ castQDragMoveEventToQDropEvent ptr'
  toQDropEventConst (QDragMoveEventConstGc fptr' ptr') = M266.QDropEventConstGc fptr' $ castQDragMoveEventToQDropEvent ptr'

instance M34.QEventConstPtr QDragMoveEventConst where
  toQEventConst (QDragMoveEventConst ptr') = M34.QEventConst $ castQDragMoveEventToQEvent ptr'
  toQEventConst (QDragMoveEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQDragMoveEventToQEvent ptr'

data QDragMoveEvent =
    QDragMoveEvent (HoppyF.Ptr QDragMoveEvent)
  | QDragMoveEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QDragMoveEvent)
  deriving (HoppyP.Show)

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

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

castQDragMoveEventToNonconst :: QDragMoveEventConst -> QDragMoveEvent
castQDragMoveEventToNonconst (QDragMoveEventConst ptr') = QDragMoveEvent $ HoppyF.castPtr ptr'
castQDragMoveEventToNonconst (QDragMoveEventConstGc fptr' ptr') = QDragMoveEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QDragMoveEventConstPtr QDragMoveEvent where
  toQDragMoveEventConst (QDragMoveEvent ptr') = QDragMoveEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'
  toQDragMoveEventConst (QDragMoveEventGc fptr' ptr') = QDragMoveEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'

instance QDragMoveEventPtr QDragMoveEvent where
  toQDragMoveEvent = HoppyP.id

instance M266.QDropEventConstPtr QDragMoveEvent where
  toQDropEventConst (QDragMoveEvent ptr') = M266.QDropEventConst $ castQDragMoveEventToQDropEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'
  toQDropEventConst (QDragMoveEventGc fptr' ptr') = M266.QDropEventConstGc fptr' $ castQDragMoveEventToQDropEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'

instance M266.QDropEventPtr QDragMoveEvent where
  toQDropEvent (QDragMoveEvent ptr') = M266.QDropEvent $ (HoppyF.castPtr :: HoppyF.Ptr M266.QDropEventConst -> HoppyF.Ptr M266.QDropEvent) $ castQDragMoveEventToQDropEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'
  toQDropEvent (QDragMoveEventGc fptr' ptr') = M266.QDropEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M266.QDropEventConst -> HoppyF.Ptr M266.QDropEvent) $ castQDragMoveEventToQDropEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'

instance M34.QEventConstPtr QDragMoveEvent where
  toQEventConst (QDragMoveEvent ptr') = M34.QEventConst $ castQDragMoveEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'
  toQEventConst (QDragMoveEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQDragMoveEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'

instance M34.QEventPtr QDragMoveEvent where
  toQEvent (QDragMoveEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQDragMoveEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'
  toQEvent (QDragMoveEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQDragMoveEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QDragMoveEvent -> HoppyF.Ptr QDragMoveEventConst) ptr'

new :: (M114.QPointValue 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 QDragMoveEvent)
new arg'1 arg'2 arg'3 arg'4 arg'5 =
  M114.withQPointPtr 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 QDragMoveEvent
  (new' arg'1' arg'2' arg'3' arg'4' arg'5')

newWithType :: (M114.QPointValue 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 QDragMoveEvent)
newWithType arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 =
  M114.withQPointPtr 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 QDragMoveEvent
  (newWithType' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6')

class QDragMoveEventSuper a where
  downToQDragMoveEvent :: a -> QDragMoveEvent

instance QDragMoveEventSuper M266.QDropEvent where
  downToQDragMoveEvent = castQDragMoveEventToNonconst . cast' . M266.castQDropEventToConst
    where
      cast' (M266.QDropEventConst ptr') = QDragMoveEventConst $ castQDropEventToQDragMoveEvent ptr'
      cast' (M266.QDropEventConstGc fptr' ptr') = QDragMoveEventConstGc fptr' $ castQDropEventToQDragMoveEvent ptr'
instance QDragMoveEventSuper M34.QEvent where
  downToQDragMoveEvent = castQDragMoveEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QDragMoveEventConst $ castQEventToQDragMoveEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QDragMoveEventConstGc fptr' $ castQEventToQDragMoveEvent ptr'

class QDragMoveEventSuperConst a where
  downToQDragMoveEventConst :: a -> QDragMoveEventConst

instance QDragMoveEventSuperConst M266.QDropEventConst where
  downToQDragMoveEventConst = cast'
    where
      cast' (M266.QDropEventConst ptr') = QDragMoveEventConst $ castQDropEventToQDragMoveEvent ptr'
      cast' (M266.QDropEventConstGc fptr' ptr') = QDragMoveEventConstGc fptr' $ castQDropEventToQDragMoveEvent ptr'
instance QDragMoveEventSuperConst M34.QEventConst where
  downToQDragMoveEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QDragMoveEventConst $ castQEventToQDragMoveEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QDragMoveEventConstGc fptr' $ castQEventToQDragMoveEvent ptr'

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

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