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

module Graphics.UI.Qtah.Generated.Core.QProcess (
  castQProcessToQIODevice,
  castQIODeviceToQProcess,
  castQProcessToQObject,
  castQObjectToQProcess,
  QProcessValue (..),
  QProcessConstPtr (..),
  arguments,
  atEnd,
  bytesAvailable,
  bytesToWrite,
  canReadLine,
  error,
  exitCode,
  exitStatus,
  inputChannelMode,
  isSequential,
  processChannelMode,
  processEnvironment,
  processId,
  program,
  readChannel,
  state,
  workingDirectory,
  QProcessPtr (..),
  close,
  closeReadChannel,
  closeWriteChannel,
  open,
  openWithMode,
  readAllStandardError,
  readAllStandardOutput,
  setArguments,
  setInputChannelMode,
  setProcessChannelMode,
  setProcessEnvironment,
  setProgram,
  setReadChannel,
  setStandardErrorFile,
  setStandardErrorFileWithMode,
  setStandardInputFile,
  setStandardOutputFile,
  setStandardOutputFileWithMode,
  setStandardOutputProcess,
  setWorkingDirectory,
  start,
  startWithProgramArgMode,
  startWithCommand,
  startWithCommandMode,
  startWithMode,
  startDetached,
  systemEnvironment,
  waitForBytesWritten,
  waitForBytesWrittenMsecs,
  waitForFinished,
  waitForFinishedMsecs,
  waitForReadyRead,
  waitForReadyReadMsecs,
  waitForStarted,
  waitForStartedMsecs,
  kill,
  terminate,
  emitErrorOccurred,
  emitFinished,
  execute,
  executeWithCommand,
  nullDevice,
  startDetachedStatic,
  startDetachedStaticDir,
  startDetachedStaticCommand,
  QProcessConst (..),
  castQProcessToConst,
  QProcess (..),
  castQProcessToNonconst,
  new,
  newWithParent,
  QProcessSuper (..),
  QProcessSuperConst (..),
  QProcessExitStatus (..),
  QProcessInputChannelMode (..),
  QProcessProcessChannel (..),
  QProcessProcessChannelMode (..),
  QProcessProcessError (..),
  QProcessProcessState (..),
  ) where

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

foreign import ccall "genpop__QProcess_new" new' ::  HoppyP.IO (HoppyF.Ptr QProcess)
foreign import ccall "genpop__QProcess_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QProcess)
foreign import ccall "genpop__QProcess_arguments" arguments' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QProcess_atEnd" atEnd' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_bytesAvailable" bytesAvailable' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QProcess_bytesToWrite" bytesToWrite' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QProcess_canReadLine" canReadLine' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_close" close' ::  HoppyF.Ptr QProcess -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_closeReadChannel" closeReadChannel' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_closeWriteChannel" closeWriteChannel' ::  HoppyF.Ptr QProcess -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_error" error' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_execute" execute' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_executeWithCommand" executeWithCommand' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_exitCode" exitCode' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_exitStatus" exitStatus' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_inputChannelMode" inputChannelMode' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_isSequential" isSequential' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_nullDevice" nullDevice' ::  HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QProcess_open" open' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_openWithMode" openWithMode' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_processChannelMode" processChannelMode' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_processEnvironment" processEnvironment' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO (HoppyF.Ptr M108.QProcessEnvironmentConst)
foreign import ccall "genpop__QProcess_processId" processId' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyDI.Int64
foreign import ccall "genpop__QProcess_program" program' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QProcess_readAllStandardError" readAllStandardError' ::  HoppyF.Ptr QProcess -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QProcess_readAllStandardOutput" readAllStandardOutput' ::  HoppyF.Ptr QProcess -> HoppyP.IO (HoppyF.Ptr M12.QByteArrayConst)
foreign import ccall "genpop__QProcess_readChannel" readChannel' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_setArguments" setArguments' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setInputChannelMode" setInputChannelMode' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setProcessChannelMode" setProcessChannelMode' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setProcessEnvironment" setProcessEnvironment' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M108.QProcessEnvironmentConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setProgram" setProgram' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setReadChannel" setReadChannel' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardErrorFile" setStandardErrorFile' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardErrorFileWithMode" setStandardErrorFileWithMode' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardInputFile" setStandardInputFile' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardOutputFile" setStandardOutputFile' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardOutputFileWithMode" setStandardOutputFileWithMode' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setStandardOutputProcess" setStandardOutputProcess' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr QProcess -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_setWorkingDirectory" setWorkingDirectory' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_start" start' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_startWithProgramArgMode" startWithProgramArgMode' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_startWithCommand" startWithCommand' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_startWithCommandMode" startWithCommandMode' ::  HoppyF.Ptr QProcess -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_startWithMode" startWithMode' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_startDetached" startDetached' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_startDetachedStatic" startDetachedStatic' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_startDetachedStaticDir" startDetachedStaticDir' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_startDetachedStaticCommand" startDetachedStaticCommand' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_state" state' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QProcess_systemEnvironment" systemEnvironment' ::  HoppyF.Ptr QProcess -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QProcess_waitForBytesWritten" waitForBytesWritten' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForBytesWrittenMsecs" waitForBytesWrittenMsecs' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForFinished" waitForFinished' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForFinishedMsecs" waitForFinishedMsecs' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForReadyRead" waitForReadyRead' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForReadyReadMsecs" waitForReadyReadMsecs' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForStarted" waitForStarted' ::  HoppyF.Ptr QProcess -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_waitForStartedMsecs" waitForStartedMsecs' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QProcess_workingDirectory" workingDirectory' ::  HoppyF.Ptr QProcessConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QProcess_kill" kill' ::  HoppyF.Ptr QProcess -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_terminate" terminate' ::  HoppyF.Ptr QProcess -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_emitErrorOccurred" emitErrorOccurred' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QProcess_emitFinished" emitFinished' ::  HoppyF.Ptr QProcess -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QProcess__QIODevice" castQProcessToQIODevice :: HoppyF.Ptr QProcessConst -> HoppyF.Ptr M48.QIODeviceConst
foreign import ccall "gencast__QIODevice__QProcess" castQIODeviceToQProcess :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr QProcessConst
foreign import ccall "gencast__QProcess__QObject" castQProcessToQObject :: HoppyF.Ptr QProcessConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QProcess" castQObjectToQProcess :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QProcessConst
foreign import ccall "gendel__QProcess" delete'QProcess :: HoppyF.Ptr QProcessConst -> HoppyP.IO ()
foreign import ccall "&gendel__QProcess" deletePtr'QProcess :: HoppyF.FunPtr (HoppyF.Ptr QProcessConst -> HoppyP.IO ())

class QProcessValue a where
  withQProcessPtr :: a -> (QProcessConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QProcessConstPtr a => QProcessValue a where
  withQProcessPtr = HoppyP.flip ($) . toQProcessConst

class (M48.QIODeviceConstPtr this) => QProcessConstPtr this where
  toQProcessConst :: this -> QProcessConst

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

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

bytesAvailable :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
bytesAvailable arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (bytesAvailable' arg'1')

bytesToWrite :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
bytesToWrite arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (bytesToWrite' arg'1')

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

error :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessProcessError)
error arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (error' arg'1')

exitCode :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Int)
exitCode arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (exitCode' arg'1')

exitStatus :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessExitStatus)
exitStatus arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (exitStatus' arg'1')

inputChannelMode :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessInputChannelMode)
inputChannelMode arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (inputChannelMode' arg'1')

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

processChannelMode :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessProcessChannelMode)
processChannelMode arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (processChannelMode' arg'1')

processEnvironment :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO M108.QProcessEnvironment)
processEnvironment arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M108.QProcessEnvironmentConst) =<<
  (processEnvironment' arg'1')

processId :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDI.Int64)
processId arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (processId' arg'1')

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

readChannel :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessProcessChannel)
readChannel arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (readChannel' arg'1')

state :: (QProcessValue this) => (this) {- ^ this -} -> (HoppyP.IO QProcessProcessState)
state arg'1 =
  withQProcessPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (state' arg'1')

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

class (QProcessConstPtr this, M48.QIODevicePtr this) => QProcessPtr this where
  toQProcess :: this -> QProcess

close :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
close arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (close' arg'1')

closeReadChannel :: (QProcessPtr this) => (this) {- ^ this -} -> (QProcessProcessChannel) -> (HoppyP.IO ())
closeReadChannel arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (closeReadChannel' arg'1' arg'2')

closeWriteChannel :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
closeWriteChannel arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (closeWriteChannel' arg'1')

open :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
open arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (open' arg'1')

openWithMode :: (QProcessPtr this, M48.IsQIODeviceOpenMode arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
openWithMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (openWithMode' arg'1' arg'2')

readAllStandardError :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
readAllStandardError arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readAllStandardError' arg'1')

readAllStandardOutput :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO QtahDBS.ByteString)
readAllStandardOutput arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M12.QByteArrayConst) =<<
  (readAllStandardOutput' arg'1')

setArguments :: (QProcessPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setArguments arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setArguments' arg'1' arg'2')

setInputChannelMode :: (QProcessPtr this) => (this) {- ^ this -} -> (QProcessInputChannelMode) -> (HoppyP.IO ())
setInputChannelMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setInputChannelMode' arg'1' arg'2')

setProcessChannelMode :: (QProcessPtr this) => (this) {- ^ this -} -> (QProcessProcessChannelMode) -> (HoppyP.IO ())
setProcessChannelMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setProcessChannelMode' arg'1' arg'2')

setProcessEnvironment :: (QProcessPtr this, M108.QProcessEnvironmentValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setProcessEnvironment arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M108.withQProcessEnvironmentPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setProcessEnvironment' arg'1' arg'2')

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

setReadChannel :: (QProcessPtr this) => (this) {- ^ this -} -> (QProcessProcessChannel) -> (HoppyP.IO ())
setReadChannel arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setReadChannel' arg'1' arg'2')

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

setStandardErrorFileWithMode :: (QProcessPtr this, M142.QStringValue arg'2, M48.IsQIODeviceOpenMode arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setStandardErrorFileWithMode arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (setStandardErrorFileWithMode' arg'1' arg'2' arg'3')

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

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

setStandardOutputFileWithMode :: (QProcessPtr this, M142.QStringValue arg'2, M48.IsQIODeviceOpenMode arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
setStandardOutputFileWithMode arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (setStandardOutputFileWithMode' arg'1' arg'2' arg'3')

setStandardOutputProcess :: (QProcessPtr this, QProcessPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setStandardOutputProcess arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQProcess arg'2) $ \arg'2' ->
  (setStandardOutputProcess' arg'1' arg'2')

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

start :: (QProcessPtr this, M142.QStringValue arg'2, M144.QStringListValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
start arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M144.withQStringListPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (start' arg'1' arg'2' arg'3')

startWithProgramArgMode :: (QProcessPtr this, M142.QStringValue arg'2, M144.QStringListValue arg'3, M48.IsQIODeviceOpenMode arg'4) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO ())
startWithProgramArgMode arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M144.withQStringListPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'4 >>= \arg'4' ->
  (startWithProgramArgMode' arg'1' arg'2' arg'3' arg'4')

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

startWithCommandMode :: (QProcessPtr this, M142.QStringValue arg'2, M48.IsQIODeviceOpenMode arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
startWithCommandMode arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'3 >>= \arg'3' ->
  (startWithCommandMode' arg'1' arg'2' arg'3')

startWithMode :: (QProcessPtr this, M48.IsQIODeviceOpenMode arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
startWithMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M48.toQIODeviceOpenMode
  ) arg'2 >>= \arg'2' ->
  (startWithMode' arg'1' arg'2')

startDetached :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
startDetached arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startDetached' arg'1')

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

waitForBytesWritten :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
waitForBytesWritten arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForBytesWritten' arg'1')

waitForBytesWrittenMsecs :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForBytesWrittenMsecs arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForBytesWrittenMsecs' arg'1' arg'2')

waitForFinished :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
waitForFinished arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForFinished' arg'1')

waitForFinishedMsecs :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForFinishedMsecs arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForFinishedMsecs' arg'1' arg'2')

waitForReadyRead :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
waitForReadyRead arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForReadyRead' arg'1')

waitForReadyReadMsecs :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForReadyReadMsecs arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForReadyReadMsecs' arg'1' arg'2')

waitForStarted :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Bool)
waitForStarted arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForStarted' arg'1')

waitForStartedMsecs :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
waitForStartedMsecs arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (waitForStartedMsecs' arg'1' arg'2')

kill :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
kill arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (kill' arg'1')

terminate :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
terminate arg'1 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (terminate' arg'1')

emitErrorOccurred :: (QProcessPtr this) => (this) {- ^ this -} -> (QProcessProcessError) -> (HoppyP.IO ())
emitErrorOccurred arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitErrorOccurred' arg'1' arg'2')

emitFinished :: (QProcessPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (QProcessExitStatus) -> (HoppyP.IO ())
emitFinished arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQProcess arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (emitFinished' arg'1' arg'2' arg'3')

execute :: (M142.QStringValue arg'1, M144.QStringListValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Int)
execute arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (execute' arg'1' arg'2')

executeWithCommand :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Int)
executeWithCommand arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (executeWithCommand' arg'1')

nullDevice :: (HoppyP.IO QtahP.String)
nullDevice =
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (nullDevice')

startDetachedStatic :: (M142.QStringValue arg'1, M144.QStringListValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
startDetachedStatic arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startDetachedStatic' arg'1' arg'2')

startDetachedStaticDir :: (M142.QStringValue arg'1, M144.QStringListValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
startDetachedStaticDir arg'1 arg'2 arg'3 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startDetachedStaticDir' arg'1' arg'2' arg'3')

startDetachedStaticCommand :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO HoppyP.Bool)
startDetachedStaticCommand arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (startDetachedStaticCommand' arg'1')

data QProcessConst =
    QProcessConst (HoppyF.Ptr QProcessConst)
  | QProcessConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QProcessConst)
  deriving (HoppyP.Show)

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

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

castQProcessToConst :: QProcess -> QProcessConst
castQProcessToConst (QProcess ptr') = QProcessConst $ HoppyF.castPtr ptr'
castQProcessToConst (QProcessGc fptr' ptr') = QProcessConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QProcessConstPtr QProcessConst where
  toQProcessConst = HoppyP.id

instance M48.QIODeviceConstPtr QProcessConst where
  toQIODeviceConst (QProcessConst ptr') = M48.QIODeviceConst $ castQProcessToQIODevice ptr'
  toQIODeviceConst (QProcessConstGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQProcessToQIODevice ptr'

instance M94.QObjectConstPtr QProcessConst where
  toQObjectConst (QProcessConst ptr') = M94.QObjectConst $ castQProcessToQObject ptr'
  toQObjectConst (QProcessConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQProcessToQObject ptr'

data QProcess =
    QProcess (HoppyF.Ptr QProcess)
  | QProcessGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QProcess)
  deriving (HoppyP.Show)

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

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

castQProcessToNonconst :: QProcessConst -> QProcess
castQProcessToNonconst (QProcessConst ptr') = QProcess $ HoppyF.castPtr ptr'
castQProcessToNonconst (QProcessConstGc fptr' ptr') = QProcessGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QProcessConstPtr QProcess where
  toQProcessConst (QProcess ptr') = QProcessConst $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'
  toQProcessConst (QProcessGc fptr' ptr') = QProcessConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'

instance QProcessPtr QProcess where
  toQProcess = HoppyP.id

instance M48.QIODeviceConstPtr QProcess where
  toQIODeviceConst (QProcess ptr') = M48.QIODeviceConst $ castQProcessToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'
  toQIODeviceConst (QProcessGc fptr' ptr') = M48.QIODeviceConstGc fptr' $ castQProcessToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'

instance M48.QIODevicePtr QProcess where
  toQIODevice (QProcess ptr') = M48.QIODevice $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQProcessToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'
  toQIODevice (QProcessGc fptr' ptr') = M48.QIODeviceGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M48.QIODeviceConst -> HoppyF.Ptr M48.QIODevice) $ castQProcessToQIODevice $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'

instance M94.QObjectConstPtr QProcess where
  toQObjectConst (QProcess ptr') = M94.QObjectConst $ castQProcessToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'
  toQObjectConst (QProcessGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQProcessToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'

instance M94.QObjectPtr QProcess where
  toQObject (QProcess ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQProcessToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'
  toQObject (QProcessGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQProcessToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QProcess -> HoppyF.Ptr QProcessConst) ptr'

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

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

class QProcessSuper a where
  downToQProcess :: a -> QProcess

instance QProcessSuper M48.QIODevice where
  downToQProcess = castQProcessToNonconst . cast' . M48.castQIODeviceToConst
    where
      cast' (M48.QIODeviceConst ptr') = QProcessConst $ castQIODeviceToQProcess ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QProcessConstGc fptr' $ castQIODeviceToQProcess ptr'
instance QProcessSuper M94.QObject where
  downToQProcess = castQProcessToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QProcessConst $ castQObjectToQProcess ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QProcessConstGc fptr' $ castQObjectToQProcess ptr'

class QProcessSuperConst a where
  downToQProcessConst :: a -> QProcessConst

instance QProcessSuperConst M48.QIODeviceConst where
  downToQProcessConst = cast'
    where
      cast' (M48.QIODeviceConst ptr') = QProcessConst $ castQIODeviceToQProcess ptr'
      cast' (M48.QIODeviceConstGc fptr' ptr') = QProcessConstGc fptr' $ castQIODeviceToQProcess ptr'
instance QProcessSuperConst M94.QObjectConst where
  downToQProcessConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QProcessConst $ castQObjectToQProcess ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QProcessConstGc fptr' $ castQObjectToQProcess ptr'

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

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

data QProcessExitStatus =
  NormalExit
  | CrashExit
  | UnknownQProcessExitStatus (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessExitStatus where
  fromCppEnum NormalExit = 0
  fromCppEnum CrashExit = 1
  fromCppEnum (UnknownQProcessExitStatus n) = n
  
  toCppEnum (0) = NormalExit
  toCppEnum (1) = CrashExit
  toCppEnum n = UnknownQProcessExitStatus n

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

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

data QProcessInputChannelMode =
  ManagedInputChannel
  | ForwardedInputChannel
  | UnknownQProcessInputChannelMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessInputChannelMode where
  fromCppEnum ManagedInputChannel = 0
  fromCppEnum ForwardedInputChannel = 1
  fromCppEnum (UnknownQProcessInputChannelMode n) = n
  
  toCppEnum (0) = ManagedInputChannel
  toCppEnum (1) = ForwardedInputChannel
  toCppEnum n = UnknownQProcessInputChannelMode n

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

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

data QProcessProcessChannel =
  StandardOutput
  | StandardError
  | UnknownQProcessProcessChannel (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessProcessChannel where
  fromCppEnum StandardOutput = 0
  fromCppEnum StandardError = 1
  fromCppEnum (UnknownQProcessProcessChannel n) = n
  
  toCppEnum (0) = StandardOutput
  toCppEnum (1) = StandardError
  toCppEnum n = UnknownQProcessProcessChannel n

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

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

data QProcessProcessChannelMode =
  SeparateChannels
  | MergedChannels
  | ForwardedChannels
  | ForwardedErrorChannel
  | ForwardedOutputChannel
  | UnknownQProcessProcessChannelMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessProcessChannelMode where
  fromCppEnum SeparateChannels = 0
  fromCppEnum MergedChannels = 1
  fromCppEnum ForwardedChannels = 2
  fromCppEnum ForwardedErrorChannel = 4
  fromCppEnum ForwardedOutputChannel = 3
  fromCppEnum (UnknownQProcessProcessChannelMode n) = n
  
  toCppEnum (0) = SeparateChannels
  toCppEnum (1) = MergedChannels
  toCppEnum (2) = ForwardedChannels
  toCppEnum (3) = ForwardedOutputChannel
  toCppEnum (4) = ForwardedErrorChannel
  toCppEnum n = UnknownQProcessProcessChannelMode n

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

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

data QProcessProcessError =
  FailedToStart
  | Crashed
  | Timedout
  | WriteError
  | ReadError
  | UnknownError
  | UnknownQProcessProcessError (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessProcessError where
  fromCppEnum FailedToStart = 0
  fromCppEnum Crashed = 1
  fromCppEnum Timedout = 2
  fromCppEnum WriteError = 4
  fromCppEnum ReadError = 3
  fromCppEnum UnknownError = 5
  fromCppEnum (UnknownQProcessProcessError n) = n
  
  toCppEnum (0) = FailedToStart
  toCppEnum (1) = Crashed
  toCppEnum (2) = Timedout
  toCppEnum (3) = ReadError
  toCppEnum (4) = WriteError
  toCppEnum (5) = UnknownError
  toCppEnum n = UnknownQProcessProcessError n

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

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

data QProcessProcessState =
  NotRunning
  | Starting
  | Running
  | UnknownQProcessProcessState (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QProcessProcessState where
  fromCppEnum NotRunning = 0
  fromCppEnum Starting = 1
  fromCppEnum Running = 2
  fromCppEnum (UnknownQProcessProcessState n) = n
  
  toCppEnum (0) = NotRunning
  toCppEnum (1) = Starting
  toCppEnum (2) = Running
  toCppEnum n = UnknownQProcessProcessState n

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

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