QTranslator.hs

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

module Graphics.UI.Qtah.Generated.Core.QTranslator (
  castQTranslatorToQObject,
  castQObjectToQTranslator,
  QTranslatorValue (..),
  QTranslatorConstPtr (..),
  isEmpty,
  translate,
  translateWithDisambiguation,
  translateWithDisambiguationAndNum,
  QTranslatorPtr (..),
  loadWith,
  loadWithDir,
  loadWithDirAndDelimiters,
  loadWithDirAndDelimitersAndSuffix,
  loadFromPtrConstUchar,
  loadFromPtrConstUcharAndDir,
  QTranslatorConst (..),
  castQTranslatorToConst,
  QTranslator (..),
  castQTranslatorToNonconst,
  new,
  newWithParent,
  QTranslatorSuper (..),
  QTranslatorSuperConst (..),
  ) where

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.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QTranslator_new" new' ::  HoppyP.IO (HoppyF.Ptr QTranslator)
foreign import ccall "genpop__QTranslator_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QTranslator)
foreign import ccall "genpop__QTranslator_isEmpty" isEmpty' ::  HoppyF.Ptr QTranslatorConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadWith" loadWith' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadWithDir" loadWithDir' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadWithDirAndDelimiters" loadWithDirAndDelimiters' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadWithDirAndDelimitersAndSuffix" loadWithDirAndDelimitersAndSuffix' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadFromPtrConstUchar" loadFromPtrConstUchar' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_loadFromPtrConstUcharAndDir" loadFromPtrConstUcharAndDir' ::  HoppyF.Ptr QTranslator -> HoppyF.Ptr HoppyFC.CUChar -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QTranslator_translate" translate' ::  HoppyF.Ptr QTranslatorConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTranslator_translateWithDisambiguation" translateWithDisambiguation' ::  HoppyF.Ptr QTranslatorConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QTranslator_translateWithDisambiguationAndNum" translateWithDisambiguationAndNum' ::  HoppyF.Ptr QTranslatorConst -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyF.Ptr HoppyFC.CChar -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gencast__QTranslator__QObject" castQTranslatorToQObject :: HoppyF.Ptr QTranslatorConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QTranslator" castQObjectToQTranslator :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QTranslatorConst
foreign import ccall "gendel__QTranslator" delete'QTranslator :: HoppyF.Ptr QTranslatorConst -> HoppyP.IO ()
foreign import ccall "&gendel__QTranslator" deletePtr'QTranslator :: HoppyF.FunPtr (HoppyF.Ptr QTranslatorConst -> HoppyP.IO ())

class QTranslatorValue a where
  withQTranslatorPtr :: a -> (QTranslatorConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QTranslatorConstPtr a => QTranslatorValue a where
  withQTranslatorPtr = HoppyP.flip ($) . toQTranslatorConst

class (M94.QObjectConstPtr this) => QTranslatorConstPtr this where
  toQTranslatorConst :: this -> QTranslatorConst

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

translate :: (QTranslatorValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QtahP.String)
translate arg'1 arg'2 arg'3 =
  withQTranslatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (translate' arg'1' arg'2' arg'3')

translateWithDisambiguation :: (QTranslatorValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.IO QtahP.String)
translateWithDisambiguation arg'1 arg'2 arg'3 arg'4 =
  withQTranslatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  let arg'4' = arg'4 in
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (translateWithDisambiguation' arg'1' arg'2' arg'3' arg'4')

translateWithDisambiguationAndNum :: (QTranslatorValue this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyF.Ptr HoppyFC.CChar) -> (HoppyP.Int) -> (HoppyP.IO QtahP.String)
translateWithDisambiguationAndNum arg'1 arg'2 arg'3 arg'4 arg'5 =
  withQTranslatorPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  let arg'2' = arg'2 in
  let arg'3' = arg'3 in
  let arg'4' = arg'4 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (translateWithDisambiguationAndNum' arg'1' arg'2' arg'3' arg'4' arg'5')

class (QTranslatorConstPtr this, M94.QObjectPtr this) => QTranslatorPtr this where
  toQTranslator :: this -> QTranslator

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

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

loadWithDirAndDelimiters :: (QTranslatorPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO HoppyP.Bool)
loadWithDirAndDelimiters arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQTranslator arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadWithDirAndDelimiters' arg'1' arg'2' arg'3' arg'4')

loadWithDirAndDelimitersAndSuffix :: (QTranslatorPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'4, M142.QStringValue arg'5) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (arg'5) -> (HoppyP.IO HoppyP.Bool)
loadWithDirAndDelimitersAndSuffix arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQTranslator arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  M142.withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadWithDirAndDelimitersAndSuffix' arg'1' arg'2' arg'3' arg'4' arg'5')

loadFromPtrConstUchar :: (QTranslatorPtr this) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
loadFromPtrConstUchar arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQTranslator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadFromPtrConstUchar' arg'1' arg'2' arg'3')

loadFromPtrConstUcharAndDir :: (QTranslatorPtr this, M142.QStringValue arg'4) => (this) {- ^ this -} -> (HoppyF.Ptr HoppyFC.CUChar) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO HoppyP.Bool)
loadFromPtrConstUcharAndDir arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQTranslator arg'1) $ \arg'1' ->
  let arg'2' = arg'2 in
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  M142.withQStringPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (loadFromPtrConstUcharAndDir' arg'1' arg'2' arg'3' arg'4')

data QTranslatorConst =
    QTranslatorConst (HoppyF.Ptr QTranslatorConst)
  | QTranslatorConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTranslatorConst)
  deriving (HoppyP.Show)

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

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

castQTranslatorToConst :: QTranslator -> QTranslatorConst
castQTranslatorToConst (QTranslator ptr') = QTranslatorConst $ HoppyF.castPtr ptr'
castQTranslatorToConst (QTranslatorGc fptr' ptr') = QTranslatorConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QTranslatorConstPtr QTranslatorConst where
  toQTranslatorConst = HoppyP.id

instance M94.QObjectConstPtr QTranslatorConst where
  toQObjectConst (QTranslatorConst ptr') = M94.QObjectConst $ castQTranslatorToQObject ptr'
  toQObjectConst (QTranslatorConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQTranslatorToQObject ptr'

data QTranslator =
    QTranslator (HoppyF.Ptr QTranslator)
  | QTranslatorGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QTranslator)
  deriving (HoppyP.Show)

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

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

castQTranslatorToNonconst :: QTranslatorConst -> QTranslator
castQTranslatorToNonconst (QTranslatorConst ptr') = QTranslator $ HoppyF.castPtr ptr'
castQTranslatorToNonconst (QTranslatorConstGc fptr' ptr') = QTranslatorGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QTranslatorConstPtr QTranslator where
  toQTranslatorConst (QTranslator ptr') = QTranslatorConst $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'
  toQTranslatorConst (QTranslatorGc fptr' ptr') = QTranslatorConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'

instance QTranslatorPtr QTranslator where
  toQTranslator = HoppyP.id

instance M94.QObjectConstPtr QTranslator where
  toQObjectConst (QTranslator ptr') = M94.QObjectConst $ castQTranslatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'
  toQObjectConst (QTranslatorGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQTranslatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'

instance M94.QObjectPtr QTranslator where
  toQObject (QTranslator ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQTranslatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'
  toQObject (QTranslatorGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQTranslatorToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QTranslator -> HoppyF.Ptr QTranslatorConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QTranslator)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QTranslator
  (newWithParent' arg'1')

class QTranslatorSuper a where
  downToQTranslator :: a -> QTranslator

instance QTranslatorSuper M94.QObject where
  downToQTranslator = castQTranslatorToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QTranslatorConst $ castQObjectToQTranslator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QTranslatorConstGc fptr' $ castQObjectToQTranslator ptr'

class QTranslatorSuperConst a where
  downToQTranslatorConst :: a -> QTranslatorConst

instance QTranslatorSuperConst M94.QObjectConst where
  downToQTranslatorConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QTranslatorConst $ castQObjectToQTranslator ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QTranslatorConstGc fptr' $ castQObjectToQTranslator ptr'

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

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