QPainter.hs

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

module Graphics.UI.Qtah.Generated.Gui.QPainter (
  QPainterValue (..),
  QPainterConstPtr (..),
  QPainterPtr (..),
  drawImageAtRaw,
  drawImageAtRawAll,
  fillRectWithGlobalColor,
  setRenderHint,
  QPainterConst (..),
  castQPainterToConst,
  QPainter (..),
  castQPainterToNonconst,
  new,
  newWithDevice,
  QPainterSuper (..),
  QPainterSuperConst (..),
  QPainterRenderHint (..),
  QPainterRenderHints,
  IsQPainterRenderHints (..),
  antialiasing,
  highQualityAntialiasing,
  nonCosmeticDefaultPen,
  qt4CompatiblePainting,
  smoothPixmapTransform,
  textAntialiasing,
  ) where

import Data.Bits ((.&.), (.|.))
import qualified Data.Bits as QtahDB
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Foreign.Hoppy.Runtime as QtahFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QRect as M122
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 Prelude (($), (.), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QPainter_new" new' ::  HoppyP.IO (HoppyF.Ptr QPainter)
foreign import ccall "genpop__QPainter_newWithDevice" newWithDevice' ::  HoppyF.Ptr M304.QPaintDevice -> HoppyP.IO (HoppyF.Ptr QPainter)
foreign import ccall "genpop__QPainter_drawImageAtRaw" drawImageAtRaw' ::  HoppyF.Ptr QPainter -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M292.QImageConst -> HoppyP.IO ()
foreign import ccall "genpop__QPainter_drawImageAtRawAll" drawImageAtRawAll' ::  HoppyF.Ptr QPainter -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M292.QImageConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QPainter_fillRectWithGlobalColor" fillRectWithGlobalColor' ::  HoppyF.Ptr QPainter -> HoppyF.Ptr M122.QRectConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QPainter_setRenderHint" setRenderHint' ::  HoppyF.Ptr QPainter -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gendel__QPainter" delete'QPainter :: HoppyF.Ptr QPainterConst -> HoppyP.IO ()
foreign import ccall "&gendel__QPainter" deletePtr'QPainter :: HoppyF.FunPtr (HoppyF.Ptr QPainterConst -> HoppyP.IO ())

class QPainterValue a where
  withQPainterPtr :: a -> (QPainterConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QPainterConstPtr a => QPainterValue a where
  withQPainterPtr = HoppyP.flip ($) . toQPainterConst

class (HoppyFHR.CppPtr this) => QPainterConstPtr this where
  toQPainterConst :: this -> QPainterConst

class (QPainterConstPtr this) => QPainterPtr this where
  toQPainter :: this -> QPainter

drawImageAtRaw :: (QPainterPtr this, M292.QImageValue arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
drawImageAtRaw arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQPainter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M292.withQImagePtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (drawImageAtRaw' arg'1' arg'2' arg'3' arg'4')

drawImageAtRawAll :: (QPainterPtr this, M292.QImageValue arg'4, M190.IsQtImageConversionFlags arg'9) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'9) -> (HoppyP.IO ())
drawImageAtRawAll arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  HoppyFHR.withCppPtr (toQPainter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M292.withQImagePtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'6 >>= \arg'6' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'7 >>= \arg'7' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'8 >>= \arg'8' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtImageConversionFlags
  ) arg'9 >>= \arg'9' ->
  (drawImageAtRawAll' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

fillRectWithGlobalColor :: (QPainterPtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (M190.QtGlobalColor) -> (HoppyP.IO ())
fillRectWithGlobalColor arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQPainter arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (fillRectWithGlobalColor' arg'1' arg'2' arg'3')

setRenderHint :: (QPainterPtr this) => (this) {- ^ this -} -> (QPainterRenderHint) -> (HoppyP.IO ())
setRenderHint arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQPainter arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setRenderHint' arg'1' arg'2')

data QPainterConst =
    QPainterConst (HoppyF.Ptr QPainterConst)
  | QPainterConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPainterConst)
  deriving (HoppyP.Show)

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

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

castQPainterToConst :: QPainter -> QPainterConst
castQPainterToConst (QPainter ptr') = QPainterConst $ HoppyF.castPtr ptr'
castQPainterToConst (QPainterGc fptr' ptr') = QPainterConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QPainterConstPtr QPainterConst where
  toQPainterConst = HoppyP.id

data QPainter =
    QPainter (HoppyF.Ptr QPainter)
  | QPainterGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QPainter)
  deriving (HoppyP.Show)

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

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

castQPainterToNonconst :: QPainterConst -> QPainter
castQPainterToNonconst (QPainterConst ptr') = QPainter $ HoppyF.castPtr ptr'
castQPainterToNonconst (QPainterConstGc fptr' ptr') = QPainterGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QPainterConstPtr QPainter where
  toQPainterConst (QPainter ptr') = QPainterConst $ (HoppyF.castPtr :: HoppyF.Ptr QPainter -> HoppyF.Ptr QPainterConst) ptr'
  toQPainterConst (QPainterGc fptr' ptr') = QPainterConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QPainter -> HoppyF.Ptr QPainterConst) ptr'

instance QPainterPtr QPainter where
  toQPainter = HoppyP.id

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

newWithDevice :: (M304.QPaintDevicePtr arg'1) => (arg'1) -> (HoppyP.IO QPainter)
newWithDevice arg'1 =
  HoppyFHR.withCppPtr (M304.toQPaintDevice arg'1) $ \arg'1' ->
  HoppyP.fmap QPainter
  (newWithDevice' arg'1')

class QPainterSuper a where
  downToQPainter :: a -> QPainter


class QPainterSuperConst a where
  downToQPainterConst :: a -> QPainterConst


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

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

data QPainterRenderHint =
  Antialiasing
  | TextAntialiasing
  | SmoothPixmapTransform
  | HighQualityAntialiasing
  | NonCosmeticDefaultPen
  | Qt4CompatiblePainting
  | UnknownQPainterRenderHint (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QPainterRenderHint where
  fromCppEnum Antialiasing = 1
  fromCppEnum TextAntialiasing = 2
  fromCppEnum SmoothPixmapTransform = 4
  fromCppEnum HighQualityAntialiasing = 8
  fromCppEnum NonCosmeticDefaultPen = 16
  fromCppEnum Qt4CompatiblePainting = 32
  fromCppEnum (UnknownQPainterRenderHint n) = n
  
  toCppEnum (1) = Antialiasing
  toCppEnum (2) = TextAntialiasing
  toCppEnum (4) = SmoothPixmapTransform
  toCppEnum (8) = HighQualityAntialiasing
  toCppEnum (16) = NonCosmeticDefaultPen
  toCppEnum (32) = Qt4CompatiblePainting
  toCppEnum n = UnknownQPainterRenderHint n

instance HoppyP.Eq QPainterRenderHint where
  x == y = HoppyFHR.fromCppEnum x == HoppyFHR.fromCppEnum y

instance HoppyP.Ord QPainterRenderHint where
  compare x y = HoppyP.compare (HoppyFHR.fromCppEnum x) (HoppyFHR.fromCppEnum y)

newtype QPainterRenderHints = QPainterRenderHints (HoppyFC.CInt) deriving (QtahP.Eq, QtahP.Ord, QtahP.Show)

instance QtahFlags.Flags (HoppyFC.CInt) QPainterRenderHint QPainterRenderHints where
  enumToFlags = QPainterRenderHints . QtahFHR.fromCppEnum
  flagsToEnum (QPainterRenderHints x') = QtahFHR.toCppEnum x'

class IsQPainterRenderHints a where
  toQPainterRenderHints :: a -> QPainterRenderHints

instance IsQPainterRenderHints QPainterRenderHints where toQPainterRenderHints = QtahP.id
instance IsQPainterRenderHints QPainterRenderHint where toQPainterRenderHints = QtahFlags.enumToFlags
instance IsQPainterRenderHints (HoppyFC.CInt) where toQPainterRenderHints = QtahFlags.numToFlags

antialiasing :: QPainterRenderHints
antialiasing = QPainterRenderHints (1)

highQualityAntialiasing :: QPainterRenderHints
highQualityAntialiasing = QPainterRenderHints (8)

nonCosmeticDefaultPen :: QPainterRenderHints
nonCosmeticDefaultPen = QPainterRenderHints (16)

qt4CompatiblePainting :: QPainterRenderHints
qt4CompatiblePainting = QPainterRenderHints (32)

smoothPixmapTransform :: QPainterRenderHints
smoothPixmapTransform = QPainterRenderHints (4)

textAntialiasing :: QPainterRenderHints
textAntialiasing = QPainterRenderHints (2)

instance QtahDB.Bits QPainterRenderHints where
  x .&. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .&. QtahFlags.flagsToNum y)
  x .|. y = QtahFlags.numToFlags (QtahFlags.flagsToNum x .|. QtahFlags.flagsToNum y)
  xor x y = QtahFlags.numToFlags $ QtahDB.xor (QtahFlags.flagsToNum x) (QtahFlags.flagsToNum y)
  complement x = QtahFlags.numToFlags $ QtahDB.complement $ QtahFlags.flagsToNum x
  shift x i = QtahFlags.numToFlags $ QtahDB.shift (QtahFlags.flagsToNum x) i
  rotate x i = QtahFlags.numToFlags $ QtahDB.rotate (QtahFlags.flagsToNum x) i
  bitSize x = case QtahDB.bitSizeMaybe x of
      QtahP.Just n -> n
      QtahP.Nothing -> QtahP.error "bitSize is undefined"
  bitSizeMaybe = QtahDB.bitSizeMaybe . QtahFlags.flagsToNum
  isSigned = QtahDB.isSigned . QtahFlags.flagsToNum
  testBit x i = QtahDB.testBit (QtahFlags.flagsToNum x) i
  bit = QtahFlags.numToFlags . QtahDB.bit
  popCount = QtahDB.popCount . QtahFlags.flagsToNum