QInputDialog.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QInputDialog (
  castQInputDialogToQDialog,
  castQDialogToQInputDialog,
  castQInputDialogToQWidget,
  castQWidgetToQInputDialog,
  castQInputDialogToQObject,
  castQObjectToQInputDialog,
  QInputDialogValue (..),
  QInputDialogConstPtr (..),
  cancelButtonText,
  isComboBoxEditable,
  comboBoxItems,
  doubleDecimals,
  doubleMaximum,
  doubleMinimum,
  doubleValue,
  inputMode,
  intMaximum,
  intMinimum,
  intStep,
  intValue,
  labelText,
  okButtonText,
  options,
  testOption,
  textEchoMode,
  textValue,
  QInputDialogPtr (..),
  setCancelButtonText,
  setComboBoxEditable,
  setComboBoxItems,
  setDoubleDecimals,
  setDoubleMaximum,
  setDoubleMinimum,
  setDoubleValue,
  setInputMode,
  setIntMaximum,
  setIntMinimum,
  setIntStep,
  setIntValue,
  setLabelText,
  setOkButtonText,
  setOptions,
  setDoubleRange,
  setIntRange,
  setOption,
  setTextEchoMode,
  setTextValue,
  emitDoubleValueChanged,
  emitDoubleValueSelected,
  emitIntValueChanged,
  emitIntValueSelected,
  emitTextValueChanged,
  emitTextValueSelected,
  getDouble,
  getDoubleWithOptions,
  getInt,
  getIntWithOptions,
  getItem,
  getItemWithOptions,
  getMultiLineText,
  getMultiLineTextWithOptions,
  getText,
  getTextWithOptions,
  QInputDialogConst (..),
  castQInputDialogToConst,
  QInputDialog (..),
  castQInputDialogToNonconst,
  new,
  newWithParent,
  newWithParentAndFlags,
  QInputDialogSuper (..),
  QInputDialogSuperConst (..),
  QInputDialogInputDialogOption (..),
  QInputDialogInputDialogOptions,
  IsQInputDialogInputDialogOptions (..),
  noButtons,
  useListViewForComboBoxItems,
  usePlainTextEditForTextInput,
  QInputDialogInputMode (..),
  ) 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.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.Types as M190
import qualified Graphics.UI.Qtah.Generated.Widgets.QDialog as M388
import qualified Graphics.UI.Qtah.Generated.Widgets.QLineEdit as M438
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QInputDialog_new" new' ::  HoppyP.IO (HoppyF.Ptr QInputDialog)
foreign import ccall "genpop__QInputDialog_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QInputDialog)
foreign import ccall "genpop__QInputDialog_newWithParentAndFlags" newWithParentAndFlags' ::  HoppyF.Ptr M506.QWidget -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QInputDialog)
foreign import ccall "genpop__QInputDialog_cancelButtonText" cancelButtonText' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_setCancelButtonText" setCancelButtonText' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_isComboBoxEditable" isComboBoxEditable' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QInputDialog_setComboBoxEditable" setComboBoxEditable' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_comboBoxItems" comboBoxItems' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO (HoppyF.Ptr M144.QStringListConst)
foreign import ccall "genpop__QInputDialog_setComboBoxItems" setComboBoxItems' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_doubleDecimals" doubleDecimals' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setDoubleDecimals" setDoubleDecimals' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_doubleMaximum" doubleMaximum' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QInputDialog_setDoubleMaximum" setDoubleMaximum' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_doubleMinimum" doubleMinimum' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QInputDialog_setDoubleMinimum" setDoubleMinimum' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_doubleValue" doubleValue' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QInputDialog_setDoubleValue" setDoubleValue' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_getDouble" getDouble' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QInputDialog_getDoubleWithOptions" getDoubleWithOptions' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QInputDialog_getInt" getInt' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_getIntWithOptions" getIntWithOptions' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_getItem" getItem' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_getItemWithOptions" getItemWithOptions' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M144.QStringListConst -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_getMultiLineText" getMultiLineText' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_getMultiLineTextWithOptions" getMultiLineTextWithOptions' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_getText" getText' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_getTextWithOptions" getTextWithOptions' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr HoppyFC.CBool -> HoppyFC.CInt -> HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_inputMode" inputMode' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setInputMode" setInputMode' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_intMaximum" intMaximum' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setIntMaximum" setIntMaximum' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_intMinimum" intMinimum' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setIntMinimum" setIntMinimum' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_intStep" intStep' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setIntStep" setIntStep' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_intValue" intValue' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setIntValue" setIntValue' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_labelText" labelText' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_setLabelText" setLabelText' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_okButtonText" okButtonText' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_setOkButtonText" setOkButtonText' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_options" options' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setOptions" setOptions' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_setDoubleRange" setDoubleRange' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_setIntRange" setIntRange' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_setOption" setOption' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_testOption" testOption' ::  HoppyF.Ptr QInputDialogConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QInputDialog_textEchoMode" textEchoMode' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QInputDialog_setTextEchoMode" setTextEchoMode' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_textValue" textValue' ::  HoppyF.Ptr QInputDialogConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QInputDialog_setTextValue" setTextValue' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitDoubleValueChanged" emitDoubleValueChanged' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitDoubleValueSelected" emitDoubleValueSelected' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitIntValueChanged" emitIntValueChanged' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitIntValueSelected" emitIntValueSelected' ::  HoppyF.Ptr QInputDialog -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitTextValueChanged" emitTextValueChanged' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QInputDialog_emitTextValueSelected" emitTextValueSelected' ::  HoppyF.Ptr QInputDialog -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "gencast__QInputDialog__QDialog" castQInputDialogToQDialog :: HoppyF.Ptr QInputDialogConst -> HoppyF.Ptr M388.QDialogConst
foreign import ccall "gencast__QDialog__QInputDialog" castQDialogToQInputDialog :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr QInputDialogConst
foreign import ccall "gencast__QInputDialog__QWidget" castQInputDialogToQWidget :: HoppyF.Ptr QInputDialogConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QInputDialog" castQWidgetToQInputDialog :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QInputDialogConst
foreign import ccall "gencast__QInputDialog__QObject" castQInputDialogToQObject :: HoppyF.Ptr QInputDialogConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QInputDialog" castQObjectToQInputDialog :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QInputDialogConst
foreign import ccall "gendel__QInputDialog" delete'QInputDialog :: HoppyF.Ptr QInputDialogConst -> HoppyP.IO ()
foreign import ccall "&gendel__QInputDialog" deletePtr'QInputDialog :: HoppyF.FunPtr (HoppyF.Ptr QInputDialogConst -> HoppyP.IO ())

class QInputDialogValue a where
  withQInputDialogPtr :: a -> (QInputDialogConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QInputDialogConstPtr a => QInputDialogValue a where
  withQInputDialogPtr = HoppyP.flip ($) . toQInputDialogConst

class (M388.QDialogConstPtr this) => QInputDialogConstPtr this where
  toQInputDialogConst :: this -> QInputDialogConst

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

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

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

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

doubleMaximum :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
doubleMaximum arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (doubleMaximum' arg'1')

doubleMinimum :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
doubleMinimum arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (doubleMinimum' arg'1')

doubleValue :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyP.Double)
doubleValue arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (doubleValue' arg'1')

inputMode :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO QInputDialogInputMode)
inputMode arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (inputMode' arg'1')

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

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

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

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

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

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

options :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO QInputDialogInputDialogOptions)
options arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (options' arg'1')

testOption :: (QInputDialogValue this) => (this) {- ^ this -} -> (QInputDialogInputDialogOption) -> (HoppyP.IO HoppyP.Bool)
testOption arg'1 arg'2 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (testOption' arg'1' arg'2')

textEchoMode :: (QInputDialogValue this) => (this) {- ^ this -} -> (HoppyP.IO M438.QLineEditEchoMode)
textEchoMode arg'1 =
  withQInputDialogPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (textEchoMode' arg'1')

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

class (QInputDialogConstPtr this, M388.QDialogPtr this) => QInputDialogPtr this where
  toQInputDialog :: this -> QInputDialog

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

setComboBoxEditable :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Bool) -> (HoppyP.IO ())
setComboBoxEditable arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'2 >>= \arg'2' ->
  (setComboBoxEditable' arg'1' arg'2')

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

setDoubleDecimals :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setDoubleDecimals arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setDoubleDecimals' arg'1' arg'2')

setDoubleMaximum :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setDoubleMaximum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setDoubleMaximum' arg'1' arg'2')

setDoubleMinimum :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setDoubleMinimum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setDoubleMinimum' arg'1' arg'2')

setDoubleValue :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
setDoubleValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (setDoubleValue' arg'1' arg'2')

setInputMode :: (QInputDialogPtr this) => (this) {- ^ this -} -> (QInputDialogInputMode) -> (HoppyP.IO ())
setInputMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setInputMode' arg'1' arg'2')

setIntMaximum :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setIntMaximum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setIntMaximum' arg'1' arg'2')

setIntMinimum :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setIntMinimum arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setIntMinimum' arg'1' arg'2')

setIntStep :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setIntStep arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setIntStep' arg'1' arg'2')

setIntValue :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
setIntValue arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (setIntValue' arg'1' arg'2')

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

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

setOptions :: (QInputDialogPtr this, IsQInputDialogInputDialogOptions arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setOptions arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQInputDialogInputDialogOptions
  ) arg'2 >>= \arg'2' ->
  (setOptions' arg'1' arg'2')

setDoubleRange :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.IO ())
setDoubleRange arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'3 >>= \arg'3' ->
  (setDoubleRange' arg'1' arg'2' arg'3')

setIntRange :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
setIntRange arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setIntRange' arg'1' arg'2' arg'3')

setOption :: (QInputDialogPtr this) => (this) {- ^ this -} -> (QInputDialogInputDialogOption) -> (HoppyP.Bool) -> (HoppyP.IO ())
setOption arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'3 >>= \arg'3' ->
  (setOption' arg'1' arg'2' arg'3')

setTextEchoMode :: (QInputDialogPtr this) => (this) {- ^ this -} -> (M438.QLineEditEchoMode) -> (HoppyP.IO ())
setTextEchoMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setTextEchoMode' arg'1' arg'2')

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

emitDoubleValueChanged :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
emitDoubleValueChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (emitDoubleValueChanged' arg'1' arg'2')

emitDoubleValueSelected :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Double) -> (HoppyP.IO ())
emitDoubleValueSelected arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (emitDoubleValueSelected' arg'1' arg'2')

emitIntValueChanged :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitIntValueChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitIntValueChanged' arg'1' arg'2')

emitIntValueSelected :: (QInputDialogPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO ())
emitIntValueSelected arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQInputDialog arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (emitIntValueSelected' arg'1' arg'2')

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

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

getDouble :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Double)
getDouble arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (M506.toQWidget 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 . HoppyP.realToFrac
  ) =<<
  (getDouble' arg'1' arg'2' arg'3')

getDoubleWithOptions :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M190.IsQtWindowFlags arg'9) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Double) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CBool) -> (arg'9) -> (HoppyP.IO HoppyP.Double)
getDoubleWithOptions arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  HoppyFHR.withCppPtr (M506.toQWidget 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 . HoppyP.realToFrac
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'6 >>= \arg'6' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'7 >>= \arg'7' ->
  let arg'8' = arg'8 in
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'9 >>= \arg'9' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) =<<
  (getDoubleWithOptions' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

getInt :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO HoppyP.Int)
getInt arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (M506.toQWidget 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 . HoppyFHR.coerceIntegral
  ) =<<
  (getInt' arg'1' arg'2' arg'3')

getIntWithOptions :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M190.IsQtWindowFlags arg'9) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyF.Ptr HoppyFC.CBool) -> (arg'9) -> (HoppyP.IO HoppyP.Int)
getIntWithOptions arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  HoppyFHR.withCppPtr (M506.toQWidget 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 . HoppyFHR.coerceIntegral
  ) arg'4 >>= \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' ->
  let arg'8' = arg'8 in
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'9 >>= \arg'9' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) =<<
  (getIntWithOptions' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

getItem :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M144.QStringListValue arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.IO QtahP.String)
getItem arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M144.withQStringListPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getItem' arg'1' arg'2' arg'3' arg'4')

getItemWithOptions :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M144.QStringListValue arg'4, M190.IsQtWindowFlags arg'8, M190.IsQtInputMethodHints arg'9) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyP.Int) -> (HoppyP.Bool) -> (HoppyF.Ptr HoppyFC.CBool) -> (arg'8) -> (arg'9) -> (HoppyP.IO QtahP.String)
getItemWithOptions arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 arg'9 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  M144.withQStringListPtr arg'4 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (
    \x -> HoppyP.return $ if x then 1 else 0
  ) arg'6 >>= \arg'6' ->
  let arg'7' = arg'7 in
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'8 >>= \arg'8' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtInputMethodHints
  ) arg'9 >>= \arg'9' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getItemWithOptions' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8' arg'9')

getMultiLineText :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QtahP.String)
getMultiLineText arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getMultiLineText' arg'1' arg'2' arg'3')

getMultiLineTextWithOptions :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'4, M190.IsQtWindowFlags arg'6, M190.IsQtInputMethodHints arg'7) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (HoppyF.Ptr HoppyFC.CBool) -> (arg'6) -> (arg'7) -> (HoppyP.IO QtahP.String)
getMultiLineTextWithOptions arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 =
  HoppyFHR.withCppPtr (M506.toQWidget 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' ->
  let arg'5' = arg'5 in
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'6 >>= \arg'6' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtInputMethodHints
  ) arg'7 >>= \arg'7' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getMultiLineTextWithOptions' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7')

getText :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QtahP.String)
getText arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getText' arg'1' arg'2' arg'3')

getTextWithOptions :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, M142.QStringValue arg'5, M190.IsQtWindowFlags arg'7, M190.IsQtInputMethodHints arg'8) => (arg'1) -> (arg'2) -> (arg'3) -> (M438.QLineEditEchoMode) -> (arg'5) -> (HoppyF.Ptr HoppyFC.CBool) -> (arg'7) -> (arg'8) -> (HoppyP.IO QtahP.String)
getTextWithOptions arg'1 arg'2 arg'3 arg'4 arg'5 arg'6 arg'7 arg'8 =
  HoppyFHR.withCppPtr (M506.toQWidget 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 . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  M142.withQStringPtr arg'5 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'5' ->
  let arg'6' = arg'6 in
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'7 >>= \arg'7' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtInputMethodHints
  ) arg'8 >>= \arg'8' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (getTextWithOptions' arg'1' arg'2' arg'3' arg'4' arg'5' arg'6' arg'7' arg'8')

data QInputDialogConst =
    QInputDialogConst (HoppyF.Ptr QInputDialogConst)
  | QInputDialogConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QInputDialogConst)
  deriving (HoppyP.Show)

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

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

castQInputDialogToConst :: QInputDialog -> QInputDialogConst
castQInputDialogToConst (QInputDialog ptr') = QInputDialogConst $ HoppyF.castPtr ptr'
castQInputDialogToConst (QInputDialogGc fptr' ptr') = QInputDialogConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QInputDialogConstPtr QInputDialogConst where
  toQInputDialogConst = HoppyP.id

instance M388.QDialogConstPtr QInputDialogConst where
  toQDialogConst (QInputDialogConst ptr') = M388.QDialogConst $ castQInputDialogToQDialog ptr'
  toQDialogConst (QInputDialogConstGc fptr' ptr') = M388.QDialogConstGc fptr' $ castQInputDialogToQDialog ptr'

instance M506.QWidgetConstPtr QInputDialogConst where
  toQWidgetConst (QInputDialogConst ptr') = M506.QWidgetConst $ castQInputDialogToQWidget ptr'
  toQWidgetConst (QInputDialogConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQInputDialogToQWidget ptr'

instance M94.QObjectConstPtr QInputDialogConst where
  toQObjectConst (QInputDialogConst ptr') = M94.QObjectConst $ castQInputDialogToQObject ptr'
  toQObjectConst (QInputDialogConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQInputDialogToQObject ptr'

data QInputDialog =
    QInputDialog (HoppyF.Ptr QInputDialog)
  | QInputDialogGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QInputDialog)
  deriving (HoppyP.Show)

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

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

castQInputDialogToNonconst :: QInputDialogConst -> QInputDialog
castQInputDialogToNonconst (QInputDialogConst ptr') = QInputDialog $ HoppyF.castPtr ptr'
castQInputDialogToNonconst (QInputDialogConstGc fptr' ptr') = QInputDialogGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QInputDialogConstPtr QInputDialog where
  toQInputDialogConst (QInputDialog ptr') = QInputDialogConst $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQInputDialogConst (QInputDialogGc fptr' ptr') = QInputDialogConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance QInputDialogPtr QInputDialog where
  toQInputDialog = HoppyP.id

instance M388.QDialogConstPtr QInputDialog where
  toQDialogConst (QInputDialog ptr') = M388.QDialogConst $ castQInputDialogToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQDialogConst (QInputDialogGc fptr' ptr') = M388.QDialogConstGc fptr' $ castQInputDialogToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance M388.QDialogPtr QInputDialog where
  toQDialog (QInputDialog ptr') = M388.QDialog $ (HoppyF.castPtr :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr M388.QDialog) $ castQInputDialogToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQDialog (QInputDialogGc fptr' ptr') = M388.QDialogGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr M388.QDialog) $ castQInputDialogToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance M506.QWidgetConstPtr QInputDialog where
  toQWidgetConst (QInputDialog ptr') = M506.QWidgetConst $ castQInputDialogToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQWidgetConst (QInputDialogGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQInputDialogToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance M506.QWidgetPtr QInputDialog where
  toQWidget (QInputDialog ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQInputDialogToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQWidget (QInputDialogGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQInputDialogToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance M94.QObjectConstPtr QInputDialog where
  toQObjectConst (QInputDialog ptr') = M94.QObjectConst $ castQInputDialogToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQObjectConst (QInputDialogGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQInputDialogToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

instance M94.QObjectPtr QInputDialog where
  toQObject (QInputDialog ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQInputDialogToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'
  toQObject (QInputDialogGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQInputDialogToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QInputDialog -> HoppyF.Ptr QInputDialogConst) ptr'

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

newWithParent :: (M506.QWidgetPtr arg'1) => (arg'1) -> (HoppyP.IO QInputDialog)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QInputDialog
  (newWithParent' arg'1')

newWithParentAndFlags :: (M506.QWidgetPtr arg'1, M190.IsQtWindowFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QInputDialog)
newWithParentAndFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QInputDialog
  (newWithParentAndFlags' arg'1' arg'2')

class QInputDialogSuper a where
  downToQInputDialog :: a -> QInputDialog

instance QInputDialogSuper M388.QDialog where
  downToQInputDialog = castQInputDialogToNonconst . cast' . M388.castQDialogToConst
    where
      cast' (M388.QDialogConst ptr') = QInputDialogConst $ castQDialogToQInputDialog ptr'
      cast' (M388.QDialogConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQDialogToQInputDialog ptr'
instance QInputDialogSuper M506.QWidget where
  downToQInputDialog = castQInputDialogToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QInputDialogConst $ castQWidgetToQInputDialog ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQWidgetToQInputDialog ptr'
instance QInputDialogSuper M94.QObject where
  downToQInputDialog = castQInputDialogToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QInputDialogConst $ castQObjectToQInputDialog ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQObjectToQInputDialog ptr'

class QInputDialogSuperConst a where
  downToQInputDialogConst :: a -> QInputDialogConst

instance QInputDialogSuperConst M388.QDialogConst where
  downToQInputDialogConst = cast'
    where
      cast' (M388.QDialogConst ptr') = QInputDialogConst $ castQDialogToQInputDialog ptr'
      cast' (M388.QDialogConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQDialogToQInputDialog ptr'
instance QInputDialogSuperConst M506.QWidgetConst where
  downToQInputDialogConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QInputDialogConst $ castQWidgetToQInputDialog ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQWidgetToQInputDialog ptr'
instance QInputDialogSuperConst M94.QObjectConst where
  downToQInputDialogConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QInputDialogConst $ castQObjectToQInputDialog ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QInputDialogConstGc fptr' $ castQObjectToQInputDialog ptr'

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

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

data QInputDialogInputDialogOption =
  NoButtons
  | UseListViewForComboBoxItems
  | UsePlainTextEditForTextInput
  | UnknownQInputDialogInputDialogOption (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QInputDialogInputDialogOption where
  fromCppEnum NoButtons = 1
  fromCppEnum UseListViewForComboBoxItems = 2
  fromCppEnum UsePlainTextEditForTextInput = 4
  fromCppEnum (UnknownQInputDialogInputDialogOption n) = n
  
  toCppEnum (1) = NoButtons
  toCppEnum (2) = UseListViewForComboBoxItems
  toCppEnum (4) = UsePlainTextEditForTextInput
  toCppEnum n = UnknownQInputDialogInputDialogOption n

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

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

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

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

class IsQInputDialogInputDialogOptions a where
  toQInputDialogInputDialogOptions :: a -> QInputDialogInputDialogOptions

instance IsQInputDialogInputDialogOptions QInputDialogInputDialogOptions where toQInputDialogInputDialogOptions = QtahP.id
instance IsQInputDialogInputDialogOptions QInputDialogInputDialogOption where toQInputDialogInputDialogOptions = QtahFlags.enumToFlags
instance IsQInputDialogInputDialogOptions (HoppyFC.CInt) where toQInputDialogInputDialogOptions = QtahFlags.numToFlags

noButtons :: QInputDialogInputDialogOptions
noButtons = QInputDialogInputDialogOptions (1)

useListViewForComboBoxItems :: QInputDialogInputDialogOptions
useListViewForComboBoxItems = QInputDialogInputDialogOptions (2)

usePlainTextEditForTextInput :: QInputDialogInputDialogOptions
usePlainTextEditForTextInput = QInputDialogInputDialogOptions (4)

instance QtahDB.Bits QInputDialogInputDialogOptions 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

data QInputDialogInputMode =
  TextInput
  | IntInput
  | DoubleInput
  | UnknownQInputDialogInputMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QInputDialogInputMode where
  fromCppEnum TextInput = 0
  fromCppEnum IntInput = 1
  fromCppEnum DoubleInput = 2
  fromCppEnum (UnknownQInputDialogInputMode n) = n
  
  toCppEnum (0) = TextInput
  toCppEnum (1) = IntInput
  toCppEnum (2) = DoubleInput
  toCppEnum n = UnknownQInputDialogInputMode n

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

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