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

module Graphics.UI.Qtah.Generated.Gui.QGradient (
  QGradientValue (..),
  QGradientConstPtr (..),
  coordinateMode,
  spread,
  getType,
  eQ,
  nE,
  QGradientPtr (..),
  setCoordinateMode,
  setColorAt,
  setSpread,
  QGradientConst (..),
  castQGradientToConst,
  QGradient (..),
  castQGradientToNonconst,
  new,
  newCopy,
  QGradientSuper (..),
  QGradientSuperConst (..),
  QGradientCoordinateMode (..),
  QGradientPreset (..),
  QGradientSpread (..),
  QGradientType (..),
  ) 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.Generated.Gui.QColor as M252
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QGradient_new" new' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QGradient)
foreign import ccall "genpop__QGradient_newCopy" newCopy' ::  HoppyF.Ptr QGradientConst -> HoppyP.IO (HoppyF.Ptr QGradient)
foreign import ccall "genpop__QGradient_coordinateMode" coordinateMode' ::  HoppyF.Ptr QGradientConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QGradient_setCoordinateMode" setCoordinateMode' ::  HoppyF.Ptr QGradient -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGradient_setColorAt" setColorAt' ::  HoppyF.Ptr QGradient -> HoppyFC.CDouble -> HoppyF.Ptr M252.QColorConst -> HoppyP.IO ()
foreign import ccall "genpop__QGradient_spread" spread' ::  HoppyF.Ptr QGradientConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QGradient_setSpread" setSpread' ::  HoppyF.Ptr QGradient -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QGradient_getType" getType' ::  HoppyF.Ptr QGradientConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QGradient_EQ" eQ' ::  HoppyF.Ptr QGradientConst -> HoppyF.Ptr QGradientConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QGradient_NE" nE' ::  HoppyF.Ptr QGradientConst -> HoppyF.Ptr QGradientConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QGradient" delete'QGradient :: HoppyF.Ptr QGradientConst -> HoppyP.IO ()
foreign import ccall "&gendel__QGradient" deletePtr'QGradient :: HoppyF.FunPtr (HoppyF.Ptr QGradientConst -> HoppyP.IO ())

class QGradientValue a where
  withQGradientPtr :: a -> (QGradientConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QGradientConstPtr a => QGradientValue a where
  withQGradientPtr = HoppyP.flip ($) . toQGradientConst

class (HoppyFHR.CppPtr this) => QGradientConstPtr this where
  toQGradientConst :: this -> QGradientConst

coordinateMode :: (QGradientValue this) => (this) {- ^ this -} -> (HoppyP.IO QGradientCoordinateMode)
coordinateMode arg'1 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (coordinateMode' arg'1')

spread :: (QGradientValue this) => (this) {- ^ this -} -> (HoppyP.IO QGradientSpread)
spread arg'1 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (spread' arg'1')

getType :: (QGradientValue this) => (this) {- ^ this -} -> (HoppyP.IO QGradientType)
getType arg'1 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (getType' arg'1')

eQ :: (QGradientValue this, QGradientValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGradientPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QGradientValue this, QGradientValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQGradientPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QGradientConstPtr this) => QGradientPtr this where
  toQGradient :: this -> QGradient

setCoordinateMode :: (QGradientPtr this) => (this) {- ^ this -} -> (QGradientCoordinateMode) -> (HoppyP.IO ())
setCoordinateMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGradient arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setCoordinateMode' arg'1' arg'2')

setColorAt :: (QGradientPtr this, M252.QColorValue arg'3) => (this) {- ^ this -} -> (HoppyP.Double) -> (arg'3) -> (HoppyP.IO ())
setColorAt arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQGradient arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  M252.withQColorPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setColorAt' arg'1' arg'2' arg'3')

setSpread :: (QGradientPtr this) => (this) {- ^ this -} -> (QGradientSpread) -> (HoppyP.IO ())
setSpread arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQGradient arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setSpread' arg'1' arg'2')

data QGradientConst =
    QGradientConst (HoppyF.Ptr QGradientConst)
  | QGradientConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGradientConst)
  deriving (HoppyP.Show)

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

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

castQGradientToConst :: QGradient -> QGradientConst
castQGradientToConst (QGradient ptr') = QGradientConst $ HoppyF.castPtr ptr'
castQGradientToConst (QGradientGc fptr' ptr') = QGradientConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QGradientConst QGradient where copy = newCopy

instance QGradientConstPtr QGradientConst where
  toQGradientConst = HoppyP.id

data QGradient =
    QGradient (HoppyF.Ptr QGradient)
  | QGradientGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QGradient)
  deriving (HoppyP.Show)

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

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

castQGradientToNonconst :: QGradientConst -> QGradient
castQGradientToNonconst (QGradientConst ptr') = QGradient $ HoppyF.castPtr ptr'
castQGradientToNonconst (QGradientConstGc fptr' ptr') = QGradientGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QGradient QGradient where copy = newCopy

instance QGradientConstPtr QGradient where
  toQGradientConst (QGradient ptr') = QGradientConst $ (HoppyF.castPtr :: HoppyF.Ptr QGradient -> HoppyF.Ptr QGradientConst) ptr'
  toQGradientConst (QGradientGc fptr' ptr') = QGradientConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QGradient -> HoppyF.Ptr QGradientConst) ptr'

instance QGradientPtr QGradient where
  toQGradient = HoppyP.id

new :: (QGradientPreset) -> (HoppyP.IO QGradient)
new arg'1 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QGradient
  (new' arg'1')

newCopy :: (QGradientValue arg'1) => (arg'1) -> (HoppyP.IO QGradient)
newCopy arg'1 =
  withQGradientPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QGradient
  (newCopy' arg'1')

class QGradientSuper a where
  downToQGradient :: a -> QGradient


class QGradientSuperConst a where
  downToQGradientConst :: a -> QGradientConst


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

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

instance HoppyFHR.Decodable QGradient (QGradient) where
  decode = HoppyFHR.decode . toQGradientConst

instance HoppyFHR.Decodable QGradientConst (QGradient) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QGradientCoordinateMode =
  LogicalMode
  | StretchToDeviceMode
  | ObjectBoundingMode
  | ObjectMode
  | UnknownQGradientCoordinateMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGradientCoordinateMode where
  fromCppEnum LogicalMode = 0
  fromCppEnum StretchToDeviceMode = 1
  fromCppEnum ObjectBoundingMode = 2
  fromCppEnum ObjectMode = 3
  fromCppEnum (UnknownQGradientCoordinateMode n) = n
  
  toCppEnum (0) = LogicalMode
  toCppEnum (1) = StretchToDeviceMode
  toCppEnum (2) = ObjectBoundingMode
  toCppEnum (3) = ObjectMode
  toCppEnum n = UnknownQGradientCoordinateMode n

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

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

data QGradientPreset =
  WarmFlame
  | UnknownQGradientPreset (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGradientPreset where
  fromCppEnum WarmFlame = 1
  fromCppEnum (UnknownQGradientPreset n) = n
  
  toCppEnum (1) = WarmFlame
  toCppEnum n = UnknownQGradientPreset n

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

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

data QGradientSpread =
  PadSpread
  | ReflectSpread
  | RepeatSpread
  | UnknownQGradientSpread (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGradientSpread where
  fromCppEnum PadSpread = 0
  fromCppEnum ReflectSpread = 1
  fromCppEnum RepeatSpread = 2
  fromCppEnum (UnknownQGradientSpread n) = n
  
  toCppEnum (0) = PadSpread
  toCppEnum (1) = ReflectSpread
  toCppEnum (2) = RepeatSpread
  toCppEnum n = UnknownQGradientSpread n

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

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

data QGradientType =
  LinearGradient
  | RadialGradient
  | ConicalGradient
  | NoGradient
  | UnknownQGradientType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QGradientType where
  fromCppEnum LinearGradient = 0
  fromCppEnum RadialGradient = 1
  fromCppEnum ConicalGradient = 2
  fromCppEnum NoGradient = 3
  fromCppEnum (UnknownQGradientType n) = n
  
  toCppEnum (0) = LinearGradient
  toCppEnum (1) = RadialGradient
  toCppEnum (2) = ConicalGradient
  toCppEnum (3) = NoGradient
  toCppEnum n = UnknownQGradientType n

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

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