QSaveFile.hs

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

module Graphics.UI.Qtah.Generated.Core.QSaveFile (
  castQSaveFileToQFileDevice,
  castQFileDeviceToQSaveFile,
  castQSaveFileToQIODevice,
  castQIODeviceToQSaveFile,
  castQSaveFileToQObject,
  castQObjectToQSaveFile,
  QSaveFileValue (..),
  QSaveFileConstPtr (..),
  directWriteFallback,
  QSaveFilePtr (..),
  cancelWriting,
  commit,
  setDirectWriteFallback,
  setFileName,
  QSaveFileConst (..),
  castQSaveFileToConst,
  QSaveFile (..),
  castQSaveFileToNonconst,
  newWithNameAndParent,
  new,
  newWithParent,
  newWithName,
  QSaveFileSuper (..),
  QSaveFileSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QFileDevice as M38
import qualified Graphics.UI.Qtah.Generated.Core.QIODevice as M48
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QSaveFile_newWithNameAndParent" newWithNameAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QSaveFile)
foreign import ccall "genpop__QSaveFile_new" new' ::  HoppyP.IO (HoppyF.Ptr QSaveFile)
foreign import ccall "genpop__QSaveFile_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QSaveFile)
foreign import ccall "genpop__QSaveFile_newWithName" newWithName' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QSaveFile)
foreign import ccall "genpop__QSaveFile_cancelWriting" cancelWriting' ::  HoppyF.Ptr QSaveFile -> HoppyP.IO ()
foreign import ccall "genpop__QSaveFile_commit" commit' ::  HoppyF.Ptr QSaveFile -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSaveFile_directWriteFallback" directWriteFallback' ::  HoppyF.Ptr QSaveFileConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSaveFile_setDirectWriteFallback" setDirectWriteFallback' ::  HoppyF.Ptr QSaveFile -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSaveFile_setFileName" setFileName' ::  HoppyF.Ptr QSaveFile -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QSaveFile__QFileDevice" castQSaveFileToQFileDevice :: HoppyF.Ptr QSaveFileConst -> HoppyF.Ptr M38.QFileDeviceConst
foreign import ccall "gencast__QFileDevice__QSaveFile" castQFileDeviceToQSaveFile :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr QSaveFileConst
foreign import ccall "gencast__QSaveFile__QIODevice" castQSaveFileToQIODevice :: HoppyF.Ptr QSaveFileConst -> HoppyF.Ptr M48.QIODeviceConst
foreign import ccall "gencast__QIODevice__QSaveFile" castQIODeviceToQSaveFile :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr QSaveFileConst
foreign import ccall "gencast__QSaveFile__QObject" castQSaveFileToQObject :: HoppyF.Ptr QSaveFileConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QSaveFile" castQObjectToQSaveFile :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QSaveFileConst
foreign import ccall "gendel__QSaveFile" delete'QSaveFile :: HoppyF.Ptr QSaveFileConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSaveFile" deletePtr'QSaveFile :: HoppyF.FunPtr (HoppyF.Ptr QSaveFileConst -> HoppyP.IO ())

class QSaveFileValue a where
  withQSaveFilePtr :: a -> (QSaveFileConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QSaveFileConstPtr a => QSaveFileValue a where
  withQSaveFilePtr = HoppyP.flip ($) . toQSaveFileConst

class (M38.QFileDeviceConstPtr this) => QSaveFileConstPtr this where
  toQSaveFileConst :: this -> QSaveFileConst

directWriteFallback :: (QSaveFileValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
directWriteFallback arg'1 =
  withQSaveFilePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (directWriteFallback' arg'1')

class (QSaveFileConstPtr this, M38.QFileDevicePtr this) => QSaveFilePtr this where
  toQSaveFile :: this -> QSaveFile

cancelWriting :: (QSaveFilePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
cancelWriting arg'1 =
  HoppyFHR.withCppPtr (toQSaveFile arg'1) $ \arg'1' ->
  (cancelWriting' arg'1')

commit :: (QSaveFilePtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
commit arg'1 =
  HoppyFHR.withCppPtr (toQSaveFile arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (commit' arg'1')

setDirectWriteFallback :: (QSaveFilePtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setDirectWriteFallback arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSaveFile arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setDirectWriteFallback' arg'1' arg'2')

setFileName :: (QSaveFilePtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFileName arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSaveFile arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFileName' arg'1' arg'2')

data QSaveFileConst =
    QSaveFileConst (HoppyF.Ptr QSaveFileConst)
  | QSaveFileConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSaveFileConst)
  deriving (HoppyP.Show)

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

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

castQSaveFileToConst :: QSaveFile -> QSaveFileConst
castQSaveFileToConst (QSaveFile ptr') = QSaveFileConst $ HoppyF.castPtr ptr'
castQSaveFileToConst (QSaveFileGc fptr' ptr') = QSaveFileConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSaveFileConstPtr QSaveFileConst where
  toQSaveFileConst = HoppyP.id

instance M38.QFileDeviceConstPtr QSaveFileConst where
  toQFileDeviceConst (QSaveFileConst ptr') = M38.QFileDeviceConst $ castQSaveFileToQFileDevice ptr'
  toQFileDeviceConst (QSaveFileConstGc fptr' ptr') = M38.QFileDeviceConstGc fptr' $ castQSaveFileToQFileDevice ptr'

instance M48.QIODeviceConstPtr QSaveFileConst where
  toQIODeviceConst (QSaveFileConst ptr') = M48.QIODeviceConst $ castQSaveFileToQIODevice ptr'
  toQIODeviceConst (QSaveFileConstGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQSaveFileToQIODevice ptr'

instance M94.QObjectConstPtr QSaveFileConst where
  toQObjectConst (QSaveFileConst ptr') = M94.QObjectConst $ castQSaveFileToQObject ptr'
  toQObjectConst (QSaveFileConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSaveFileToQObject ptr'

data QSaveFile =
    QSaveFile (HoppyF.Ptr QSaveFile)
  | QSaveFileGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSaveFile)
  deriving (HoppyP.Show)

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

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

castQSaveFileToNonconst :: QSaveFileConst -> QSaveFile
castQSaveFileToNonconst (QSaveFileConst ptr') = QSaveFile $ HoppyF.castPtr ptr'
castQSaveFileToNonconst (QSaveFileConstGc fptr' ptr') = QSaveFileGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSaveFileConstPtr QSaveFile where
  toQSaveFileConst (QSaveFile ptr') = QSaveFileConst $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQSaveFileConst (QSaveFileGc fptr' ptr') = QSaveFileConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance QSaveFilePtr QSaveFile where
  toQSaveFile = HoppyP.id

instance M38.QFileDeviceConstPtr QSaveFile where
  toQFileDeviceConst (QSaveFile ptr') = M38.QFileDeviceConst $ castQSaveFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQFileDeviceConst (QSaveFileGc fptr' ptr') = M38.QFileDeviceConstGc fptr' $ castQSaveFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance M38.QFileDevicePtr QSaveFile where
  toQFileDevice (QSaveFile ptr') = M38.QFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr M38.QFileDevice) $ castQSaveFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQFileDevice (QSaveFileGc fptr' ptr') = M38.QFileDeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M38.QFileDeviceConst -> HoppyF.Ptr M38.QFileDevice) $ castQSaveFileToQFileDevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance M48.QIODeviceConstPtr QSaveFile where
  toQIODeviceConst (QSaveFile ptr') = M48.QIODeviceConst $ castQSaveFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQIODeviceConst (QSaveFileGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQSaveFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance M48.QIODevicePtr QSaveFile where
  toQIODevice (QSaveFile ptr') = M48.QIODevice $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQSaveFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQIODevice (QSaveFileGc fptr' ptr') = M48.QIODeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQSaveFileToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance M94.QObjectConstPtr QSaveFile where
  toQObjectConst (QSaveFile ptr') = M94.QObjectConst $ castQSaveFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQObjectConst (QSaveFileGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSaveFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

instance M94.QObjectPtr QSaveFile where
  toQObject (QSaveFile ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSaveFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'
  toQObject (QSaveFileGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSaveFileToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSaveFile -> HoppyF.Ptr QSaveFileConst) ptr'

newWithNameAndParent :: (M142.QStringValue arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QSaveFile)
newWithNameAndParent arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QSaveFile
  (newWithNameAndParent' arg'1' arg'2')

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QSaveFile)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QSaveFile
  (newWithParent' arg'1')

newWithName :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QSaveFile)
newWithName arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QSaveFile
  (newWithName' arg'1')

class QSaveFileSuper a where
  downToQSaveFile :: a -> QSaveFile

instance QSaveFileSuper M38.QFileDevice where
  downToQSaveFile = castQSaveFileToNonconst . cast' . M38.castQFileDeviceToConst
    where
      cast' (M38.QFileDeviceConst ptr') = QSaveFileConst $ castQFileDeviceToQSaveFile ptr'
      cast' (M38.QFileDeviceConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQFileDeviceToQSaveFile ptr'
instance QSaveFileSuper M48.QIODevice where
  downToQSaveFile = castQSaveFileToNonconst . cast' . M48.castQIODeviceToConst
    where
      cast' (M48.QIODeviceConst ptr') = QSaveFileConst $ castQIODeviceToQSaveFile ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQIODeviceToQSaveFile ptr'
instance QSaveFileSuper M94.QObject where
  downToQSaveFile = castQSaveFileToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QSaveFileConst $ castQObjectToQSaveFile ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQObjectToQSaveFile ptr'

class QSaveFileSuperConst a where
  downToQSaveFileConst :: a -> QSaveFileConst

instance QSaveFileSuperConst M38.QFileDeviceConst where
  downToQSaveFileConst = cast'
    where
      cast' (M38.QFileDeviceConst ptr') = QSaveFileConst $ castQFileDeviceToQSaveFile ptr'
      cast' (M38.QFileDeviceConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQFileDeviceToQSaveFile ptr'
instance QSaveFileSuperConst M48.QIODeviceConst where
  downToQSaveFileConst = cast'
    where
      cast' (M48.QIODeviceConst ptr') = QSaveFileConst $ castQIODeviceToQSaveFile ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQIODeviceToQSaveFile ptr'
instance QSaveFileSuperConst M94.QObjectConst where
  downToQSaveFileConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QSaveFileConst $ castQObjectToQSaveFile ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSaveFileConstGc fptr' $ castQObjectToQSaveFile ptr'

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

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