QFileOpenEvent.hs

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

module Graphics.UI.Qtah.Generated.Gui.QFileOpenEvent (
  castQFileOpenEventToQEvent,
  castQEventToQFileOpenEvent,
  QFileOpenEventValue (..),
  QFileOpenEventConstPtr (..),
  file,
  openFile,
  QFileOpenEventPtr (..),
  QFileOpenEventConst (..),
  castQFileOpenEventToConst,
  QFileOpenEvent (..),
  castQFileOpenEventToNonconst,
  QFileOpenEventSuper (..),
  QFileOpenEventSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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.QFile as M36
import qualified Graphics.UI.Qtah.Generated.Core.QIODevice as M48
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QFileOpenEvent_file" file' ::  HoppyF.Ptr QFileOpenEventConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QFileOpenEvent_openFile" openFile' ::  HoppyF.Ptr QFileOpenEventConst -> HoppyF.Ptr M36.QFile -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gencast__QFileOpenEvent__QEvent" castQFileOpenEventToQEvent :: HoppyF.Ptr QFileOpenEventConst -> HoppyF.Ptr M34.QEventConst
foreign import ccall "gencast__QEvent__QFileOpenEvent" castQEventToQFileOpenEvent :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr QFileOpenEventConst
foreign import ccall "gendel__QFileOpenEvent" delete'QFileOpenEvent :: HoppyF.Ptr QFileOpenEventConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFileOpenEvent" deletePtr'QFileOpenEvent :: HoppyF.FunPtr (HoppyF.Ptr QFileOpenEventConst -> HoppyP.IO ())

class QFileOpenEventValue a where
  withQFileOpenEventPtr :: a -> (QFileOpenEventConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFileOpenEventConstPtr a => QFileOpenEventValue a where
  withQFileOpenEventPtr = HoppyP.flip ($) . toQFileOpenEventConst

class (M34.QEventConstPtr this) => QFileOpenEventConstPtr this where
  toQFileOpenEventConst :: this -> QFileOpenEventConst

file :: (QFileOpenEventValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
file arg'1 =
  withQFileOpenEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (file' arg'1')

openFile :: (QFileOpenEventValue this, M36.QFilePtr arg'2, M48.IsQIODeviceOpenMode arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
openFile arg'1 arg'2 arg'3 =
  withQFileOpenEventPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M36.toQFile arg'2) $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (openFile' arg'1' arg'2' arg'3')

class (QFileOpenEventConstPtr this, M34.QEventPtr this) => QFileOpenEventPtr this where
  toQFileOpenEvent :: this -> QFileOpenEvent

data QFileOpenEventConst =
    QFileOpenEventConst (HoppyF.Ptr QFileOpenEventConst)
  | QFileOpenEventConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileOpenEventConst)
  deriving (HoppyP.Show)

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

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

castQFileOpenEventToConst :: QFileOpenEvent -> QFileOpenEventConst
castQFileOpenEventToConst (QFileOpenEvent ptr') = QFileOpenEventConst $ HoppyF.castPtr ptr'
castQFileOpenEventToConst (QFileOpenEventGc fptr' ptr') = QFileOpenEventConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileOpenEventConstPtr QFileOpenEventConst where
  toQFileOpenEventConst = HoppyP.id

instance M34.QEventConstPtr QFileOpenEventConst where
  toQEventConst (QFileOpenEventConst ptr') = M34.QEventConst $ castQFileOpenEventToQEvent ptr'
  toQEventConst (QFileOpenEventConstGc fptr' ptr') = M34.QEventConstGc fptr' $ castQFileOpenEventToQEvent ptr'

data QFileOpenEvent =
    QFileOpenEvent (HoppyF.Ptr QFileOpenEvent)
  | QFileOpenEventGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFileOpenEvent)
  deriving (HoppyP.Show)

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

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

castQFileOpenEventToNonconst :: QFileOpenEventConst -> QFileOpenEvent
castQFileOpenEventToNonconst (QFileOpenEventConst ptr') = QFileOpenEvent $ HoppyF.castPtr ptr'
castQFileOpenEventToNonconst (QFileOpenEventConstGc fptr' ptr') = QFileOpenEventGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFileOpenEventConstPtr QFileOpenEvent where
  toQFileOpenEventConst (QFileOpenEvent ptr') = QFileOpenEventConst $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'
  toQFileOpenEventConst (QFileOpenEventGc fptr' ptr') = QFileOpenEventConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'

instance QFileOpenEventPtr QFileOpenEvent where
  toQFileOpenEvent = HoppyP.id

instance M34.QEventConstPtr QFileOpenEvent where
  toQEventConst (QFileOpenEvent ptr') = M34.QEventConst $ castQFileOpenEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'
  toQEventConst (QFileOpenEventGc fptr' ptr') = M34.QEventConstGc fptr' $ castQFileOpenEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'

instance M34.QEventPtr QFileOpenEvent where
  toQEvent (QFileOpenEvent ptr') = M34.QEvent $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQFileOpenEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'
  toQEvent (QFileOpenEventGc fptr' ptr') = M34.QEventGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M34.QEventConst -> HoppyF.Ptr M34.QEvent) $ castQFileOpenEventToQEvent $ (HoppyF.castPtr :: HoppyF.Ptr QFileOpenEvent -> HoppyF.Ptr QFileOpenEventConst) ptr'

class QFileOpenEventSuper a where
  downToQFileOpenEvent :: a -> QFileOpenEvent

instance QFileOpenEventSuper M34.QEvent where
  downToQFileOpenEvent = castQFileOpenEventToNonconst . cast' . M34.castQEventToConst
    where
      cast' (M34.QEventConst ptr') = QFileOpenEventConst $ castQEventToQFileOpenEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QFileOpenEventConstGc fptr' $ castQEventToQFileOpenEvent ptr'

class QFileOpenEventSuperConst a where
  downToQFileOpenEventConst :: a -> QFileOpenEventConst

instance QFileOpenEventSuperConst M34.QEventConst where
  downToQFileOpenEventConst = cast'
    where
      cast' (M34.QEventConst ptr') = QFileOpenEventConst $ castQEventToQFileOpenEvent ptr'
      cast' (M34.QEventConstGc fptr' ptr') = QFileOpenEventConstGc fptr' $ castQEventToQFileOpenEvent ptr'

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

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