QMimeData.hs

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

module Graphics.UI.Qtah.Generated.Core.QMimeData (
  castQMimeDataToQObject,
  castQObjectToQMimeData,
  QMimeDataValue (..),
  QMimeDataConstPtr (..),
  colorData,
  getData,
  formats,
  hasColor,
  hasFormat,
  hasHtml,
  hasImage,
  hasText,
  hasUrls,
  html,
  imageData,
  text,
  QMimeDataPtr (..),
  clear,
  setColorData,
  setHtml,
  setImageData,
  removeFormat,
  setData,
  setText,
  QMimeDataConst (..),
  castQMimeDataToConst,
  QMimeData (..),
  castQMimeDataToNonconst,
  new,
  QMimeDataSuper (..),
  QMimeDataSuperConst (..),
  ) where

import qualified Data.ByteString as QtahDBS
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.QByteArray as M12
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import qualified Graphics.UI.Qtah.Generated.Core.QVariant as M168
import Prelude (($), (.), (/=), (=<<), (==))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QMimeData_new" new' ::  HoppyP.IO (HoppyF.Ptr QMimeData)
foreign import ccall "genpop__QMimeData_clear" clear' ::  HoppyF.Ptr QMimeData -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_colorData" colorData' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QMimeData_setColorData" setColorData' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_getData" getData' ::  HoppyF.Ptr QMimeDataConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QMimeData_formats" formats' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QMimeData_hasColor" hasColor' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_hasFormat" hasFormat' ::  HoppyF.Ptr QMimeDataConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_hasHtml" hasHtml' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_hasImage" hasImage' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_hasText" hasText' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_hasUrls" hasUrls' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QMimeData_html" html' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMimeData_setHtml" setHtml' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_imageData" imageData' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QMimeData_setImageData" setImageData' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_removeFormat" removeFormat' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_setData" setData' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M12.QByteArrayConst -> HoppyP.IO ()
foreign import ccall "genpop__QMimeData_text" text' ::  HoppyF.Ptr QMimeDataConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMimeData_setText" setText' ::  HoppyF.Ptr QMimeData -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QMimeData__QObject" castQMimeDataToQObject :: HoppyF.Ptr QMimeDataConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QMimeData" castQObjectToQMimeData :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QMimeDataConst
foreign import ccall "gendel__QMimeData" delete'QMimeData :: HoppyF.Ptr QMimeDataConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMimeData" deletePtr'QMimeData :: HoppyF.FunPtr (HoppyF.Ptr QMimeDataConst -> HoppyP.IO ())

class QMimeDataValue a where
  withQMimeDataPtr :: a -> (QMimeDataConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMimeDataConstPtr a => QMimeDataValue a where
  withQMimeDataPtr = HoppyP.flip ($) . toQMimeDataConst

class (M94.QObjectConstPtr this) => QMimeDataConstPtr this where
  toQMimeDataConst :: this -> QMimeDataConst

colorData :: (QMimeDataValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
colorData arg'1 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (colorData' arg'1')

getData :: (QMimeDataValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahDBS.ByteString)
getData arg'1 arg'2 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (getData' arg'1' arg'2')

formats :: (QMimeDataValue this) => (this) {- ^ this -} -> (HoppyP.IO [QtahP.String])
formats arg'1 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M144.QStringListConst) =<<
  (formats' arg'1')

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

hasFormat :: (QMimeDataValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
hasFormat arg'1 arg'2 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (hasFormat' arg'1' arg'2')

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

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

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

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

html :: (QMimeDataValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
html arg'1 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (html' arg'1')

imageData :: (QMimeDataValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
imageData arg'1 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (imageData' arg'1')

text :: (QMimeDataValue this) => (this) {- ^ this -} -> (HoppyP.IO QtahP.String)
text arg'1 =
  withQMimeDataPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (text' arg'1')

class (QMimeDataConstPtr this, M94.QObjectPtr this) => QMimeDataPtr this where
  toQMimeData :: this -> QMimeData

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

setColorData :: (QMimeDataPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setColorData arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMimeData arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setColorData' arg'1' arg'2')

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

setImageData :: (QMimeDataPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setImageData arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMimeData arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setImageData' arg'1' arg'2')

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

setData :: (QMimeDataPtr this, M142.QStringValue arg'2, M12.QByteArrayValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setData arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQMimeData arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M12.withQByteArrayPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (setData' arg'1' arg'2' arg'3')

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

data QMimeDataConst =
    QMimeDataConst (HoppyF.Ptr QMimeDataConst)
  | QMimeDataConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMimeDataConst)
  deriving (HoppyP.Show)

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

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

castQMimeDataToConst :: QMimeData -> QMimeDataConst
castQMimeDataToConst (QMimeData ptr') = QMimeDataConst $ HoppyF.castPtr ptr'
castQMimeDataToConst (QMimeDataGc fptr' ptr') = QMimeDataConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMimeDataConstPtr QMimeDataConst where
  toQMimeDataConst = HoppyP.id

instance M94.QObjectConstPtr QMimeDataConst where
  toQObjectConst (QMimeDataConst ptr') = M94.QObjectConst $ castQMimeDataToQObject ptr'
  toQObjectConst (QMimeDataConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQMimeDataToQObject ptr'

data QMimeData =
    QMimeData (HoppyF.Ptr QMimeData)
  | QMimeDataGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMimeData)
  deriving (HoppyP.Show)

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

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

castQMimeDataToNonconst :: QMimeDataConst -> QMimeData
castQMimeDataToNonconst (QMimeDataConst ptr') = QMimeData $ HoppyF.castPtr ptr'
castQMimeDataToNonconst (QMimeDataConstGc fptr' ptr') = QMimeDataGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMimeDataConstPtr QMimeData where
  toQMimeDataConst (QMimeData ptr') = QMimeDataConst $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'
  toQMimeDataConst (QMimeDataGc fptr' ptr') = QMimeDataConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'

instance QMimeDataPtr QMimeData where
  toQMimeData = HoppyP.id

instance M94.QObjectConstPtr QMimeData where
  toQObjectConst (QMimeData ptr') = M94.QObjectConst $ castQMimeDataToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'
  toQObjectConst (QMimeDataGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQMimeDataToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'

instance M94.QObjectPtr QMimeData where
  toQObject (QMimeData ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQMimeDataToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'
  toQObject (QMimeDataGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQMimeDataToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMimeData -> HoppyF.Ptr QMimeDataConst) ptr'

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

class QMimeDataSuper a where
  downToQMimeData :: a -> QMimeData

instance QMimeDataSuper M94.QObject where
  downToQMimeData = castQMimeDataToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QMimeDataConst $ castQObjectToQMimeData ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QMimeDataConstGc fptr' $ castQObjectToQMimeData ptr'

class QMimeDataSuperConst a where
  downToQMimeDataConst :: a -> QMimeDataConst

instance QMimeDataSuperConst M94.QObjectConst where
  downToQMimeDataConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QMimeDataConst $ castQObjectToQMimeData ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QMimeDataConstGc fptr' $ castQObjectToQMimeData ptr'

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

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