QBackingStore.hs

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

module Graphics.UI.Qtah.Generated.Gui.QBackingStore (
  QBackingStoreValue (..),
  QBackingStoreConstPtr (..),
  hasStaticContents,
  size,
  staticContents,
  window,
  QBackingStorePtr (..),
  beginPaint,
  endPaint,
  flush,
  flushWithWindow,
  flushAll,
  paintDevice,
  resize,
  scroll,
  setStaticContents,
  QBackingStoreConst (..),
  castQBackingStoreToConst,
  QBackingStore (..),
  castQBackingStoreToNonconst,
  new,
  QBackingStoreSuper (..),
  QBackingStoreSuperConst (..),
  ) 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.HSize as HSize
import qualified Graphics.UI.Qtah.Generated.Core.QPoint as M114
import qualified Graphics.UI.Qtah.Generated.Core.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Gui.QPaintDevice as M304
import qualified Graphics.UI.Qtah.Generated.Gui.QRegion as M324
import qualified Graphics.UI.Qtah.Generated.Gui.QWindow as M342
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QBackingStore_new" new' ::  HoppyF.Ptr M342.QWindow -> HoppyP.IO (HoppyF.Ptr QBackingStore)
foreign import ccall "genpop__QBackingStore_beginPaint" beginPaint' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_endPaint" endPaint' ::  HoppyF.Ptr QBackingStore -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_flush" flush' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_flushWithWindow" flushWithWindow' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyF.Ptr M342.QWindow -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_flushAll" flushAll' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyF.Ptr M342.QWindow -> HoppyF.Ptr M114.QPointConst -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_hasStaticContents" hasStaticContents' ::  HoppyF.Ptr QBackingStoreConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QBackingStore_paintDevice" paintDevice' ::  HoppyF.Ptr QBackingStore -> HoppyP.IO (HoppyF.Ptr M304.QPaintDevice)
foreign import ccall "genpop__QBackingStore_resize" resize' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_scroll" scroll' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QBackingStore_setStaticContents" setStaticContents' ::  HoppyF.Ptr QBackingStore -> HoppyF.Ptr M324.QRegionConst -> HoppyP.IO ()
foreign import ccall "genpop__QBackingStore_size" size' ::  HoppyF.Ptr QBackingStoreConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QBackingStore_staticContents" staticContents' ::  HoppyF.Ptr QBackingStoreConst -> HoppyP.IO (HoppyF.Ptr M324.QRegionConst)
foreign import ccall "genpop__QBackingStore_window" window' ::  HoppyF.Ptr QBackingStoreConst -> HoppyP.IO (HoppyF.Ptr M342.QWindow)
foreign import ccall "gendel__QBackingStore" delete'QBackingStore :: HoppyF.Ptr QBackingStoreConst -> HoppyP.IO ()
foreign import ccall "&gendel__QBackingStore" deletePtr'QBackingStore :: HoppyF.FunPtr (HoppyF.Ptr QBackingStoreConst -> HoppyP.IO ())

class QBackingStoreValue a where
  withQBackingStorePtr :: a -> (QBackingStoreConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QBackingStoreConstPtr a => QBackingStoreValue a where
  withQBackingStorePtr = HoppyP.flip ($) . toQBackingStoreConst

class (HoppyFHR.CppPtr this) => QBackingStoreConstPtr this where
  toQBackingStoreConst :: this -> QBackingStoreConst

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

size :: (QBackingStoreValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
size arg'1 =
  withQBackingStorePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (size' arg'1')

staticContents :: (QBackingStoreValue this) => (this) {- ^ this -} -> (HoppyP.IO M324.QRegion)
staticContents arg'1 =
  withQBackingStorePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M324.QRegionConst) =<<
  (staticContents' arg'1')

window :: (QBackingStoreValue this) => (this) {- ^ this -} -> (HoppyP.IO M342.QWindow)
window arg'1 =
  withQBackingStorePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M342.QWindow
  (window' arg'1')

class (QBackingStoreConstPtr this) => QBackingStorePtr this where
  toQBackingStore :: this -> QBackingStore

beginPaint :: (QBackingStorePtr this, M324.QRegionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
beginPaint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (beginPaint' arg'1' arg'2')

endPaint :: (QBackingStorePtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
endPaint arg'1 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  (endPaint' arg'1')

flush :: (QBackingStorePtr this, M324.QRegionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
flush arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (flush' arg'1' arg'2')

flushWithWindow :: (QBackingStorePtr this, M324.QRegionValue arg'2, M342.QWindowPtr arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
flushWithWindow arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyFHR.withCppPtr (M342.toQWindow arg'3) $ \arg'3' ->
  (flushWithWindow' arg'1' arg'2' arg'3')

flushAll :: (QBackingStorePtr this, M324.QRegionValue arg'2, M342.QWindowPtr arg'3, M114.QPointValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
flushAll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyFHR.withCppPtr (M342.toQWindow arg'3) $ \arg'3' ->
  M114.withQPointPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (flushAll' arg'1' arg'2' arg'3' arg'4')

paintDevice :: (QBackingStorePtr this) => (this) {- ^ this -} -> (HoppyP.IO M304.QPaintDevice)
paintDevice arg'1 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  HoppyP.fmap M304.QPaintDevice
  (paintDevice' arg'1')

resize :: (QBackingStorePtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
resize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (resize' arg'1' arg'2')

scroll :: (QBackingStorePtr this, M324.QRegionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
scroll arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (scroll' arg'1' arg'2' arg'3' arg'4')

setStaticContents :: (QBackingStorePtr this, M324.QRegionValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setStaticContents arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBackingStore arg'1) $ \arg'1' ->
  M324.withQRegionPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setStaticContents' arg'1' arg'2')

data QBackingStoreConst =
    QBackingStoreConst (HoppyF.Ptr QBackingStoreConst)
  | QBackingStoreConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBackingStoreConst)
  deriving (HoppyP.Show)

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

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

castQBackingStoreToConst :: QBackingStore -> QBackingStoreConst
castQBackingStoreToConst (QBackingStore ptr') = QBackingStoreConst $ HoppyF.castPtr ptr'
castQBackingStoreToConst (QBackingStoreGc fptr' ptr') = QBackingStoreConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QBackingStoreConstPtr QBackingStoreConst where
  toQBackingStoreConst = HoppyP.id

data QBackingStore =
    QBackingStore (HoppyF.Ptr QBackingStore)
  | QBackingStoreGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBackingStore)
  deriving (HoppyP.Show)

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

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

castQBackingStoreToNonconst :: QBackingStoreConst -> QBackingStore
castQBackingStoreToNonconst (QBackingStoreConst ptr') = QBackingStore $ HoppyF.castPtr ptr'
castQBackingStoreToNonconst (QBackingStoreConstGc fptr' ptr') = QBackingStoreGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QBackingStoreConstPtr QBackingStore where
  toQBackingStoreConst (QBackingStore ptr') = QBackingStoreConst $ (HoppyF.castPtr :: HoppyF.Ptr QBackingStore -> HoppyF.Ptr QBackingStoreConst) ptr'
  toQBackingStoreConst (QBackingStoreGc fptr' ptr') = QBackingStoreConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QBackingStore -> HoppyF.Ptr QBackingStoreConst) ptr'

instance QBackingStorePtr QBackingStore where
  toQBackingStore = HoppyP.id

new :: (M342.QWindowPtr arg'1) => (arg'1) -> (HoppyP.IO QBackingStore)
new arg'1 =
  HoppyFHR.withCppPtr (M342.toQWindow arg'1) $ \arg'1' ->
  HoppyP.fmap QBackingStore
  (new' arg'1')

class QBackingStoreSuper a where
  downToQBackingStore :: a -> QBackingStore


class QBackingStoreSuperConst a where
  downToQBackingStoreConst :: a -> QBackingStoreConst


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

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