QBitmap.hs

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

module Graphics.UI.Qtah.Generated.Gui.QBitmap (
  castQBitmapToQPixmap,
  castQPixmapToQBitmap,
  castQBitmapToQPaintDevice,
  castQPaintDeviceToQBitmap,
  QBitmapValue (..),
  QBitmapConstPtr (..),
  transformed,
  QBitmapPtr (..),
  clear,
  swap,
  aSSIGN,
  fromData,
  fromDataAll,
  fromImage,
  fromImageAll,
  QBitmapConst (..),
  castQBitmapToConst,
  QBitmap (..),
  castQBitmapToNonconst,
  new,
  newWithSize,
  newWithSizeRaw,
  newWithFile,
  newWithFileAndFormat,
  newCopy,
  QBitmapSuper (..),
  QBitmapSuperConst (..),
  ) where

import Control.Monad ((>=>))
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.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QImage as M292
import qualified Graphics.UI.Qtah.Generated.Gui.QPaintDevice as M304
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QPixmap as M316
import qualified Graphics.UI.Qtah.Generated.Gui.QTransform as M336
import Prelude (($), (.), (=<<), (==), (>>), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QBitmap_new" new' ::  HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_newWithSize" newWithSize' ::  HoppyF.Ptr M134.QSizeConst -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_newWithSizeRaw" newWithSizeRaw' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_newWithFile" newWithFile' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_newWithFileAndFormat" newWithFileAndFormat' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_newCopy" newCopy' ::  HoppyF.Ptr QBitmapConst -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "genpop__QBitmap_clear" clear' ::  HoppyF.Ptr QBitmap -> HoppyP.IO ()
foreign import ccall "genpop__QBitmap_swap" swap' ::  HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmap -> HoppyP.IO ()
foreign import ccall "genpop__QBitmap_transformed" transformed' ::  HoppyF.Ptr QBitmapConst -> HoppyF.Ptr M336.QTransformConst -> HoppyP.IO (HoppyF.Ptr QBitmapConst)
foreign import ccall "genpop__QBitmap_fromData" fromData' ::  HoppyF.Ptr M134.QSizeConst -> HoppyF.Ptr HoppyFC.CUChar -> HoppyP.IO (HoppyF.Ptr QBitmapConst)
foreign import ccall "genpop__QBitmap_fromDataAll" fromDataAll' ::  HoppyF.Ptr M134.QSizeConst -> HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QBitmapConst)
foreign import ccall "genpop__QBitmap_fromImage" fromImage' ::  HoppyF.Ptr M292.QImageConst -> HoppyP.IO (HoppyF.Ptr QBitmapConst)
foreign import ccall "genpop__QBitmap_fromImageAll" fromImageAll' ::  HoppyF.Ptr M292.QImageConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QBitmapConst)
foreign import ccall "genpop__QBitmap_ASSIGN" aSSIGN' ::  HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst -> HoppyP.IO (HoppyF.Ptr QBitmap)
foreign import ccall "gencast__QBitmap__QPixmap" castQBitmapToQPixmap :: HoppyF.Ptr QBitmapConst -> HoppyF.Ptr M316.QPixmapConst
foreign import ccall "gencast__QPixmap__QBitmap" castQPixmapToQBitmap :: HoppyF.Ptr M316.QPixmapConst -> HoppyF.Ptr QBitmapConst
foreign import ccall "gencast__QBitmap__QPaintDevice" castQBitmapToQPaintDevice :: HoppyF.Ptr QBitmapConst -> HoppyF.Ptr M304.QPaintDeviceConst
foreign import ccall "gencast__QPaintDevice__QBitmap" castQPaintDeviceToQBitmap :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr QBitmapConst
foreign import ccall "gendel__QBitmap" delete'QBitmap :: HoppyF.Ptr QBitmapConst -> HoppyP.IO ()
foreign import ccall "&gendel__QBitmap" deletePtr'QBitmap :: HoppyF.FunPtr (HoppyF.Ptr QBitmapConst -> HoppyP.IO ())

class QBitmapValue a where
  withQBitmapPtr :: a -> (QBitmapConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QBitmapConstPtr a => QBitmapValue a where
  withQBitmapPtr = HoppyP.flip ($) . toQBitmapConst

class (M316.QPixmapConstPtr this) => QBitmapConstPtr this where
  toQBitmapConst :: this -> QBitmapConst

transformed :: (QBitmapValue this, M336.QTransformValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QBitmap)
transformed arg'1 arg'2 =
  withQBitmapPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M336.withQTransformPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . QBitmapConst) =<<
  (transformed' arg'1' arg'2')

class (QBitmapConstPtr this, M316.QPixmapPtr this) => QBitmapPtr this where
  toQBitmap :: this -> QBitmap

clear :: (QBitmapPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
clear arg'1 =
  HoppyFHR.withCppPtr (toQBitmap arg'1) $ \arg'1' ->
  (clear' arg'1')

swap :: (QBitmapPtr this, QBitmapPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
swap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBitmap arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQBitmap arg'2) $ \arg'2' ->
  (swap' arg'1' arg'2')

aSSIGN :: (QBitmapPtr this, QBitmapValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QBitmap)
aSSIGN arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQBitmap arg'1) $ \arg'1' ->
  withQBitmapPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QBitmap
  (aSSIGN' arg'1' arg'2')

fromData :: (M134.QSizeValue arg'1) => (arg'1) -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.IO QBitmap)
fromData arg'1 arg'2 =
  M134.withQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (HoppyFHR.decodeAndDelete . QBitmapConst) =<<
  (fromData' arg'1' arg'2')

fromDataAll :: (M134.QSizeValue arg'1) => (arg'1) -> (HoppyF.Ptr HoppyFC.CUChar) -> (M292.QImageFormat) -> (HoppyP.IO QBitmap)
fromDataAll arg'1 arg'2 arg'3 =
  M134.withQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . QBitmapConst) =<<
  (fromDataAll' arg'1' arg'2' arg'3')

fromImage :: (M292.QImageValue arg'1) => (arg'1) -> (HoppyP.IO QBitmap)
fromImage arg'1 =
  M292.withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . QBitmapConst) =<<
  (fromImage' arg'1')

fromImageAll :: (M292.QImageValue arg'1, M190.IsQtImageConversionFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QBitmap)
fromImageAll arg'1 arg'2 =
  M292.withQImagePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtImageConversionFlags
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . QBitmapConst) =<<
  (fromImageAll' arg'1' arg'2')

data QBitmapConst =
    QBitmapConst (HoppyF.Ptr QBitmapConst)
  | QBitmapConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBitmapConst)
  deriving (HoppyP.Show)

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

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

castQBitmapToConst :: QBitmap -> QBitmapConst
castQBitmapToConst (QBitmap ptr') = QBitmapConst $ HoppyF.castPtr ptr'
castQBitmapToConst (QBitmapGc fptr' ptr') = QBitmapConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QBitmapConst QBitmap where copy = newCopy

instance QBitmapConstPtr QBitmapConst where
  toQBitmapConst = HoppyP.id

instance M316.QPixmapConstPtr QBitmapConst where
  toQPixmapConst (QBitmapConst ptr') = M316.QPixmapConst $ castQBitmapToQPixmap ptr'
  toQPixmapConst (QBitmapConstGc fptr' ptr') = M316.QPixmapConstGc fptr' $ castQBitmapToQPixmap ptr'

instance M304.QPaintDeviceConstPtr QBitmapConst where
  toQPaintDeviceConst (QBitmapConst ptr') = M304.QPaintDeviceConst $ castQBitmapToQPaintDevice ptr'
  toQPaintDeviceConst (QBitmapConstGc fptr' ptr') = M304.QPaintDeviceConstGc fptr' $ castQBitmapToQPaintDevice ptr'

data QBitmap =
    QBitmap (HoppyF.Ptr QBitmap)
  | QBitmapGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QBitmap)
  deriving (HoppyP.Show)

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

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

castQBitmapToNonconst :: QBitmapConst -> QBitmap
castQBitmapToNonconst (QBitmapConst ptr') = QBitmap $ HoppyF.castPtr ptr'
castQBitmapToNonconst (QBitmapConstGc fptr' ptr') = QBitmapGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QBitmap QBitmap where copy = newCopy

instance QBitmapConstPtr QBitmap where
  toQBitmapConst (QBitmap ptr') = QBitmapConst $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'
  toQBitmapConst (QBitmapGc fptr' ptr') = QBitmapConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'

instance QBitmapPtr QBitmap where
  toQBitmap = HoppyP.id

instance M316.QPixmapConstPtr QBitmap where
  toQPixmapConst (QBitmap ptr') = M316.QPixmapConst $ castQBitmapToQPixmap $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'
  toQPixmapConst (QBitmapGc fptr' ptr') = M316.QPixmapConstGc fptr' $ castQBitmapToQPixmap $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'

instance M316.QPixmapPtr QBitmap where
  toQPixmap (QBitmap ptr') = M316.QPixmap $ (HoppyF.castPtr :: HoppyF.Ptr M316.QPixmapConst -> HoppyF.Ptr M316.QPixmap) $ castQBitmapToQPixmap $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'
  toQPixmap (QBitmapGc fptr' ptr') = M316.QPixmapGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M316.QPixmapConst -> HoppyF.Ptr M316.QPixmap) $ castQBitmapToQPixmap $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'

instance M304.QPaintDeviceConstPtr QBitmap where
  toQPaintDeviceConst (QBitmap ptr') = M304.QPaintDeviceConst $ castQBitmapToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'
  toQPaintDeviceConst (QBitmapGc fptr' ptr') = M304.QPaintDeviceConstGc fptr' $ castQBitmapToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'

instance M304.QPaintDevicePtr QBitmap where
  toQPaintDevice (QBitmap ptr') = M304.QPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr M304.QPaintDevice) $ castQBitmapToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'
  toQPaintDevice (QBitmapGc fptr' ptr') = M304.QPaintDeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M304.QPaintDeviceConst -> HoppyF.Ptr M304.QPaintDevice) $ castQBitmapToQPaintDevice $ (HoppyF.castPtr :: HoppyF.Ptr QBitmap -> HoppyF.Ptr QBitmapConst) ptr'

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

newWithSize :: (M134.QSizeValue arg'1) => (arg'1) -> (HoppyP.IO QBitmap)
newWithSize arg'1 =
  M134.withQSizePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QBitmap
  (newWithSize' arg'1')

newWithSizeRaw :: (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QBitmap)
newWithSizeRaw arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QBitmap
  (newWithSizeRaw' arg'1' arg'2')

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

newWithFileAndFormat :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QBitmap)
newWithFileAndFormat arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  HoppyP.fmap QBitmap
  (newWithFileAndFormat' arg'1' arg'2')

newCopy :: (QBitmapValue arg'1) => (arg'1) -> (HoppyP.IO QBitmap)
newCopy arg'1 =
  withQBitmapPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QBitmap
  (newCopy' arg'1')

class QBitmapSuper a where
  downToQBitmap :: a -> QBitmap

instance QBitmapSuper M316.QPixmap where
  downToQBitmap = castQBitmapToNonconst . cast' . M316.castQPixmapToConst
    where
      cast' (M316.QPixmapConst ptr') = QBitmapConst $ castQPixmapToQBitmap ptr'
      cast' (M316.QPixmapConstGc fptr' ptr') = QBitmapConstGc fptr' $ castQPixmapToQBitmap ptr'
instance QBitmapSuper M304.QPaintDevice where
  downToQBitmap = castQBitmapToNonconst . cast' . M304.castQPaintDeviceToConst
    where
      cast' (M304.QPaintDeviceConst ptr') = QBitmapConst $ castQPaintDeviceToQBitmap ptr'
      cast' (M304.QPaintDeviceConstGc fptr' ptr') = QBitmapConstGc fptr' $ castQPaintDeviceToQBitmap ptr'

class QBitmapSuperConst a where
  downToQBitmapConst :: a -> QBitmapConst

instance QBitmapSuperConst M316.QPixmapConst where
  downToQBitmapConst = cast'
    where
      cast' (M316.QPixmapConst ptr') = QBitmapConst $ castQPixmapToQBitmap ptr'
      cast' (M316.QPixmapConstGc fptr' ptr') = QBitmapConstGc fptr' $ castQPixmapToQBitmap ptr'
instance QBitmapSuperConst M304.QPaintDeviceConst where
  downToQBitmapConst = cast'
    where
      cast' (M304.QPaintDeviceConst ptr') = QBitmapConst $ castQPaintDeviceToQBitmap ptr'
      cast' (M304.QPaintDeviceConstGc fptr' ptr') = QBitmapConstGc fptr' $ castQPaintDeviceToQBitmap ptr'

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

instance QBitmapValue a => HoppyFHR.Assignable QBitmap a where
  assign x' y' = aSSIGN x' y' >> HoppyP.return ()

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

instance HoppyFHR.Decodable QBitmap (QBitmap) where
  decode = HoppyFHR.decode . toQBitmapConst

instance HoppyFHR.Decodable QBitmapConst (QBitmap) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc