QMessageBox.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QMessageBox (
  castQMessageBoxToQDialog,
  castQDialogToQMessageBox,
  castQMessageBoxToQWidget,
  castQWidgetToQMessageBox,
  castQMessageBoxToQObject,
  castQObjectToQMessageBox,
  QMessageBoxValue (..),
  QMessageBoxConstPtr (..),
  button,
  buttonRole,
  buttons,
  checkBox,
  clickedButton,
  defaultButton,
  detailedText,
  escapeButton,
  icon,
  iconPixmap,
  informativeText,
  standardButton,
  standardButtons,
  text,
  textFormat,
  textInteractionFlags,
  QMessageBoxPtr (..),
  addButton,
  addNewButton,
  addStandardButton,
  setCheckBox,
  setDetailedText,
  setIcon,
  setIconPixmap,
  setInformativeText,
  removeButton,
  setDefaultButton,
  setDefaultButtonStandard,
  setEscapeButton,
  setEscapeButtonStandard,
  setWindowModality,
  setWindowTitle,
  setStandardButtons,
  setText,
  setTextFormat,
  setTextInteractionFlags,
  emitButtonClicked,
  about,
  aboutQt,
  critical,
  criticalWithButtons,
  information,
  informationWithButtons,
  question,
  questionWithButtons,
  warning,
  warningWithButtons,
  QMessageBoxConst (..),
  castQMessageBoxToConst,
  QMessageBox (..),
  castQMessageBoxToNonconst,
  new,
  newWithParent,
  QMessageBoxSuper (..),
  QMessageBoxSuperConst (..),
  QMessageBoxButtonRole (..),
  QMessageBoxIcon (..),
  QMessageBoxStandardButton (..),
  QMessageBoxStandardButtons,
  IsQMessageBoxStandardButtons (..),
  abort,
  apply,
  cancel,
  close,
  discard,
  help,
  ignore,
  no,
  noButton,
  noToAll,
  ok,
  open,
  reset,
  restoreDefaults,
  retry,
  save,
  saveAll,
  yes,
  yesToAll,
  ) 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.QList.QAbstractButton as M194
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.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QPixmap as M316
import qualified Graphics.UI.Qtah.Generated.Widgets.QAbstractButton as M354
import qualified Graphics.UI.Qtah.Generated.Widgets.QCheckBox as M378
import qualified Graphics.UI.Qtah.Generated.Widgets.QDialog as M388
import qualified Graphics.UI.Qtah.Generated.Widgets.QPushButton as M458
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__QMessageBox_new" new' ::  HoppyP.IO (HoppyF.Ptr QMessageBox)
foreign import ccall "genpop__QMessageBox_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QMessageBox)
foreign import ccall "genpop__QMessageBox_about" about' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_aboutQt" aboutQt' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_addButton" addButton' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M354.QAbstractButton -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_addNewButton" addNewButton' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M458.QPushButton)
foreign import ccall "genpop__QMessageBox_addStandardButton" addStandardButton' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M458.QPushButton)
foreign import ccall "genpop__QMessageBox_button" button' ::  HoppyF.Ptr QMessageBoxConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M354.QAbstractButton)
foreign import ccall "genpop__QMessageBox_buttonRole" buttonRole' ::  HoppyF.Ptr QMessageBoxConst -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_buttons" buttons' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M194.QListQAbstractButtonConst)
foreign import ccall "genpop__QMessageBox_checkBox" checkBox' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M378.QCheckBox)
foreign import ccall "genpop__QMessageBox_setCheckBox" setCheckBox' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M378.QCheckBox -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_clickedButton" clickedButton' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M354.QAbstractButton)
foreign import ccall "genpop__QMessageBox_critical" critical' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_criticalWithButtons" criticalWithButtons' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_defaultButton" defaultButton' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M458.QPushButton)
foreign import ccall "genpop__QMessageBox_detailedText" detailedText' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMessageBox_setDetailedText" setDetailedText' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_escapeButton" escapeButton' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M354.QAbstractButton)
foreign import ccall "genpop__QMessageBox_icon" icon' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_setIcon" setIcon' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_iconPixmap" iconPixmap' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M316.QPixmapConst)
foreign import ccall "genpop__QMessageBox_setIconPixmap" setIconPixmap' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M316.QPixmapConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_information" information' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_informationWithButtons" informationWithButtons' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_informativeText" informativeText' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMessageBox_setInformativeText" setInformativeText' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_question" question' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_questionWithButtons" questionWithButtons' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_removeButton" removeButton' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setDefaultButton" setDefaultButton' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M458.QPushButton -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setDefaultButtonStandard" setDefaultButtonStandard' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setEscapeButton" setEscapeButton' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M458.QPushButton -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setEscapeButtonStandard" setEscapeButtonStandard' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setWindowModality" setWindowModality' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_setWindowTitle" setWindowTitle' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_standardButton" standardButton' ::  HoppyF.Ptr QMessageBoxConst -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_standardButtons" standardButtons' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_setStandardButtons" setStandardButtons' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_text" text' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QMessageBox_setText" setText' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_textFormat" textFormat' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_setTextFormat" setTextFormat' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_textInteractionFlags" textInteractionFlags' ::  HoppyF.Ptr QMessageBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_setTextInteractionFlags" setTextInteractionFlags' ::  HoppyF.Ptr QMessageBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QMessageBox_warning" warning' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_warningWithButtons" warningWithButtons' ::  HoppyF.Ptr M506.QWidget -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QMessageBox_emitButtonClicked" emitButtonClicked' ::  HoppyF.Ptr QMessageBox -> HoppyF.Ptr M354.QAbstractButton -> HoppyP.IO ()
foreign import ccall "gencast__QMessageBox__QDialog" castQMessageBoxToQDialog :: HoppyF.Ptr QMessageBoxConst -> HoppyF.Ptr M388.QDialogConst
foreign import ccall "gencast__QDialog__QMessageBox" castQDialogToQMessageBox :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr QMessageBoxConst
foreign import ccall "gencast__QMessageBox__QWidget" castQMessageBoxToQWidget :: HoppyF.Ptr QMessageBoxConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QMessageBox" castQWidgetToQMessageBox :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QMessageBoxConst
foreign import ccall "gencast__QMessageBox__QObject" castQMessageBoxToQObject :: HoppyF.Ptr QMessageBoxConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QMessageBox" castQObjectToQMessageBox :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QMessageBoxConst
foreign import ccall "gendel__QMessageBox" delete'QMessageBox :: HoppyF.Ptr QMessageBoxConst -> HoppyP.IO ()
foreign import ccall "&gendel__QMessageBox" deletePtr'QMessageBox :: HoppyF.FunPtr (HoppyF.Ptr QMessageBoxConst -> HoppyP.IO ())

class QMessageBoxValue a where
  withQMessageBoxPtr :: a -> (QMessageBoxConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QMessageBoxConstPtr a => QMessageBoxValue a where
  withQMessageBoxPtr = HoppyP.flip ($) . toQMessageBoxConst

class (M388.QDialogConstPtr this) => QMessageBoxConstPtr this where
  toQMessageBoxConst :: this -> QMessageBoxConst

button :: (QMessageBoxValue this) => (this) {- ^ this -} -> (QMessageBoxStandardButton) -> (HoppyP.IO M354.QAbstractButton)
button arg'1 arg'2 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M354.QAbstractButton
  (button' arg'1' arg'2')

buttonRole :: (QMessageBoxValue this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QMessageBoxButtonRole)
buttonRole arg'1 arg'2 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (buttonRole' arg'1' arg'2')

buttons :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO [M354.QAbstractButton])
buttons arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M194.QListQAbstractButtonConst) =<<
  (buttons' arg'1')

checkBox :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M378.QCheckBox)
checkBox arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M378.QCheckBox
  (checkBox' arg'1')

clickedButton :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M354.QAbstractButton)
clickedButton arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M354.QAbstractButton
  (clickedButton' arg'1')

defaultButton :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M458.QPushButton)
defaultButton arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M458.QPushButton
  (defaultButton' arg'1')

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

escapeButton :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M354.QAbstractButton)
escapeButton arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M354.QAbstractButton
  (escapeButton' arg'1')

icon :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QMessageBoxIcon)
icon arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (icon' arg'1')

iconPixmap :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M316.QPixmap)
iconPixmap arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M316.QPixmapConst) =<<
  (iconPixmap' arg'1')

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

standardButton :: (QMessageBoxValue this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QMessageBoxStandardButton)
standardButton arg'1 arg'2 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (standardButton' arg'1' arg'2')

standardButtons :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QMessageBoxStandardButtons)
standardButtons arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (standardButtons' arg'1')

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

textFormat :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtTextFormat)
textFormat arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (textFormat' arg'1')

textInteractionFlags :: (QMessageBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtTextInteractionFlags)
textInteractionFlags arg'1 =
  withQMessageBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (textInteractionFlags' arg'1')

class (QMessageBoxConstPtr this, M388.QDialogPtr this) => QMessageBoxPtr this where
  toQMessageBox :: this -> QMessageBox

addButton :: (QMessageBoxPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (QMessageBoxButtonRole) -> (HoppyP.IO ())
addButton arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (addButton' arg'1' arg'2' arg'3')

addNewButton :: (QMessageBoxPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QMessageBoxButtonRole) -> (HoppyP.IO M458.QPushButton)
addNewButton arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap M458.QPushButton
  (addNewButton' arg'1' arg'2' arg'3')

addStandardButton :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (QMessageBoxStandardButton) -> (HoppyP.IO M458.QPushButton)
addStandardButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M458.QPushButton
  (addStandardButton' arg'1' arg'2')

setCheckBox :: (QMessageBoxPtr this, M378.QCheckBoxPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setCheckBox arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M378.toQCheckBox arg'2) $ \arg'2' ->
  (setCheckBox' arg'1' arg'2')

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

setIcon :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (QMessageBoxIcon) -> (HoppyP.IO ())
setIcon arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setIcon' arg'1' arg'2')

setIconPixmap :: (QMessageBoxPtr this, M316.QPixmapValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setIconPixmap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  M316.withQPixmapPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setIconPixmap' arg'1' arg'2')

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

removeButton :: (QMessageBoxPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
removeButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (removeButton' arg'1' arg'2')

setDefaultButton :: (QMessageBoxPtr this, M458.QPushButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setDefaultButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M458.toQPushButton arg'2) $ \arg'2' ->
  (setDefaultButton' arg'1' arg'2')

setDefaultButtonStandard :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (QMessageBoxStandardButton) -> (HoppyP.IO ())
setDefaultButtonStandard arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setDefaultButtonStandard' arg'1' arg'2')

setEscapeButton :: (QMessageBoxPtr this, M458.QPushButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setEscapeButton arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M458.toQPushButton arg'2) $ \arg'2' ->
  (setEscapeButton' arg'1' arg'2')

setEscapeButtonStandard :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (QMessageBoxStandardButton) -> (HoppyP.IO ())
setEscapeButtonStandard arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setEscapeButtonStandard' arg'1' arg'2')

setWindowModality :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (M190.QtWindowModality) -> (HoppyP.IO ())
setWindowModality arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setWindowModality' arg'1' arg'2')

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

setStandardButtons :: (QMessageBoxPtr this, IsQMessageBoxStandardButtons arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setStandardButtons arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQMessageBoxStandardButtons
  ) arg'2 >>= \arg'2' ->
  (setStandardButtons' arg'1' arg'2')

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

setTextFormat :: (QMessageBoxPtr this) => (this) {- ^ this -} -> (M190.QtTextFormat) -> (HoppyP.IO ())
setTextFormat arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setTextFormat' arg'1' arg'2')

setTextInteractionFlags :: (QMessageBoxPtr this, M190.IsQtTextInteractionFlags arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTextInteractionFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtTextInteractionFlags
  ) arg'2 >>= \arg'2' ->
  (setTextInteractionFlags' arg'1' arg'2')

emitButtonClicked :: (QMessageBoxPtr this, M354.QAbstractButtonPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitButtonClicked arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQMessageBox arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M354.toQAbstractButton arg'2) $ \arg'2' ->
  (emitButtonClicked' arg'1' arg'2')

about :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
about 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' ->
  (about' arg'1' arg'2' arg'3')

aboutQt :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO ())
aboutQt arg'1 arg'2 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (aboutQt' arg'1' arg'2')

critical :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QMessageBoxStandardButton)
critical 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.toCppEnum
  ) =<<
  (critical' arg'1' arg'2' arg'3')

criticalWithButtons :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, IsQMessageBoxStandardButtons arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (QMessageBoxStandardButton) -> (HoppyP.IO QMessageBoxStandardButton)
criticalWithButtons arg'1 arg'2 arg'3 arg'4 arg'5 =
  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' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQMessageBoxStandardButtons
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (criticalWithButtons' arg'1' arg'2' arg'3' arg'4' arg'5')

information :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QMessageBoxStandardButton)
information 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.toCppEnum
  ) =<<
  (information' arg'1' arg'2' arg'3')

informationWithButtons :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, IsQMessageBoxStandardButtons arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (QMessageBoxStandardButton) -> (HoppyP.IO QMessageBoxStandardButton)
informationWithButtons arg'1 arg'2 arg'3 arg'4 arg'5 =
  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' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQMessageBoxStandardButtons
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (informationWithButtons' arg'1' arg'2' arg'3' arg'4' arg'5')

question :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QMessageBoxStandardButton)
question 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.toCppEnum
  ) =<<
  (question' arg'1' arg'2' arg'3')

questionWithButtons :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, IsQMessageBoxStandardButtons arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (QMessageBoxStandardButton) -> (HoppyP.IO QMessageBoxStandardButton)
questionWithButtons arg'1 arg'2 arg'3 arg'4 arg'5 =
  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' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQMessageBoxStandardButtons
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (questionWithButtons' arg'1' arg'2' arg'3' arg'4' arg'5')

warning :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3) => (arg'1) -> (arg'2) -> (arg'3) -> (HoppyP.IO QMessageBoxStandardButton)
warning 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.toCppEnum
  ) =<<
  (warning' arg'1' arg'2' arg'3')

warningWithButtons :: (M506.QWidgetPtr arg'1, M142.QStringValue arg'2, M142.QStringValue arg'3, IsQMessageBoxStandardButtons arg'4) => (arg'1) -> (arg'2) -> (arg'3) -> (arg'4) -> (QMessageBoxStandardButton) -> (HoppyP.IO QMessageBoxStandardButton)
warningWithButtons arg'1 arg'2 arg'3 arg'4 arg'5 =
  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' ->
  (
    QtahP.return . QtahFlags.flagsToNum . toQMessageBoxStandardButtons
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'5 >>= \arg'5' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (warningWithButtons' arg'1' arg'2' arg'3' arg'4' arg'5')

data QMessageBoxConst =
    QMessageBoxConst (HoppyF.Ptr QMessageBoxConst)
  | QMessageBoxConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMessageBoxConst)
  deriving (HoppyP.Show)

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

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

castQMessageBoxToConst :: QMessageBox -> QMessageBoxConst
castQMessageBoxToConst (QMessageBox ptr') = QMessageBoxConst $ HoppyF.castPtr ptr'
castQMessageBoxToConst (QMessageBoxGc fptr' ptr') = QMessageBoxConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMessageBoxConstPtr QMessageBoxConst where
  toQMessageBoxConst = HoppyP.id

instance M388.QDialogConstPtr QMessageBoxConst where
  toQDialogConst (QMessageBoxConst ptr') = M388.QDialogConst $ castQMessageBoxToQDialog ptr'
  toQDialogConst (QMessageBoxConstGc fptr' ptr') = M388.QDialogConstGc fptr' $ castQMessageBoxToQDialog ptr'

instance M506.QWidgetConstPtr QMessageBoxConst where
  toQWidgetConst (QMessageBoxConst ptr') = M506.QWidgetConst $ castQMessageBoxToQWidget ptr'
  toQWidgetConst (QMessageBoxConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQMessageBoxToQWidget ptr'

instance M94.QObjectConstPtr QMessageBoxConst where
  toQObjectConst (QMessageBoxConst ptr') = M94.QObjectConst $ castQMessageBoxToQObject ptr'
  toQObjectConst (QMessageBoxConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQMessageBoxToQObject ptr'

data QMessageBox =
    QMessageBox (HoppyF.Ptr QMessageBox)
  | QMessageBoxGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QMessageBox)
  deriving (HoppyP.Show)

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

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

castQMessageBoxToNonconst :: QMessageBoxConst -> QMessageBox
castQMessageBoxToNonconst (QMessageBoxConst ptr') = QMessageBox $ HoppyF.castPtr ptr'
castQMessageBoxToNonconst (QMessageBoxConstGc fptr' ptr') = QMessageBoxGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QMessageBoxConstPtr QMessageBox where
  toQMessageBoxConst (QMessageBox ptr') = QMessageBoxConst $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQMessageBoxConst (QMessageBoxGc fptr' ptr') = QMessageBoxConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance QMessageBoxPtr QMessageBox where
  toQMessageBox = HoppyP.id

instance M388.QDialogConstPtr QMessageBox where
  toQDialogConst (QMessageBox ptr') = M388.QDialogConst $ castQMessageBoxToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQDialogConst (QMessageBoxGc fptr' ptr') = M388.QDialogConstGc fptr' $ castQMessageBoxToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance M388.QDialogPtr QMessageBox where
  toQDialog (QMessageBox ptr') = M388.QDialog $ (HoppyF.castPtr :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr M388.QDialog) $ castQMessageBoxToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQDialog (QMessageBoxGc fptr' ptr') = M388.QDialogGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M388.QDialogConst -> HoppyF.Ptr M388.QDialog) $ castQMessageBoxToQDialog $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance M506.QWidgetConstPtr QMessageBox where
  toQWidgetConst (QMessageBox ptr') = M506.QWidgetConst $ castQMessageBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQWidgetConst (QMessageBoxGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQMessageBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance M506.QWidgetPtr QMessageBox where
  toQWidget (QMessageBox ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQMessageBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQWidget (QMessageBoxGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQMessageBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance M94.QObjectConstPtr QMessageBox where
  toQObjectConst (QMessageBox ptr') = M94.QObjectConst $ castQMessageBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQObjectConst (QMessageBoxGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQMessageBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

instance M94.QObjectPtr QMessageBox where
  toQObject (QMessageBox ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQMessageBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'
  toQObject (QMessageBoxGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQMessageBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QMessageBox -> HoppyF.Ptr QMessageBoxConst) ptr'

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

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

class QMessageBoxSuper a where
  downToQMessageBox :: a -> QMessageBox

instance QMessageBoxSuper M388.QDialog where
  downToQMessageBox = castQMessageBoxToNonconst . cast' . M388.castQDialogToConst
    where
      cast' (M388.QDialogConst ptr') = QMessageBoxConst $ castQDialogToQMessageBox ptr'
      cast' (M388.QDialogConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQDialogToQMessageBox ptr'
instance QMessageBoxSuper M506.QWidget where
  downToQMessageBox = castQMessageBoxToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QMessageBoxConst $ castQWidgetToQMessageBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQWidgetToQMessageBox ptr'
instance QMessageBoxSuper M94.QObject where
  downToQMessageBox = castQMessageBoxToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QMessageBoxConst $ castQObjectToQMessageBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQObjectToQMessageBox ptr'

class QMessageBoxSuperConst a where
  downToQMessageBoxConst :: a -> QMessageBoxConst

instance QMessageBoxSuperConst M388.QDialogConst where
  downToQMessageBoxConst = cast'
    where
      cast' (M388.QDialogConst ptr') = QMessageBoxConst $ castQDialogToQMessageBox ptr'
      cast' (M388.QDialogConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQDialogToQMessageBox ptr'
instance QMessageBoxSuperConst M506.QWidgetConst where
  downToQMessageBoxConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QMessageBoxConst $ castQWidgetToQMessageBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQWidgetToQMessageBox ptr'
instance QMessageBoxSuperConst M94.QObjectConst where
  downToQMessageBoxConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QMessageBoxConst $ castQObjectToQMessageBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QMessageBoxConstGc fptr' $ castQObjectToQMessageBox ptr'

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

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

data QMessageBoxButtonRole =
  InvalidRole
  | AcceptRole
  | RejectRole
  | DestructiveRole
  | ActionRole
  | HelpRole
  | YesRole
  | NoRole
  | ApplyRole
  | ResetRole
  | UnknownQMessageBoxButtonRole (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QMessageBoxButtonRole where
  fromCppEnum InvalidRole = -1
  fromCppEnum AcceptRole = 0
  fromCppEnum RejectRole = 1
  fromCppEnum DestructiveRole = 2
  fromCppEnum ActionRole = 3
  fromCppEnum HelpRole = 4
  fromCppEnum YesRole = 5
  fromCppEnum NoRole = 6
  fromCppEnum ApplyRole = 8
  fromCppEnum ResetRole = 7
  fromCppEnum (UnknownQMessageBoxButtonRole n) = n
  
  toCppEnum (-1) = InvalidRole
  toCppEnum (0) = AcceptRole
  toCppEnum (1) = RejectRole
  toCppEnum (2) = DestructiveRole
  toCppEnum (3) = ActionRole
  toCppEnum (4) = HelpRole
  toCppEnum (5) = YesRole
  toCppEnum (6) = NoRole
  toCppEnum (7) = ResetRole
  toCppEnum (8) = ApplyRole
  toCppEnum n = UnknownQMessageBoxButtonRole n

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

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

data QMessageBoxIcon =
  NoIcon
  | Information
  | Warning
  | Critical
  | Question
  | UnknownQMessageBoxIcon (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QMessageBoxIcon where
  fromCppEnum NoIcon = 0
  fromCppEnum Information = 1
  fromCppEnum Warning = 2
  fromCppEnum Critical = 3
  fromCppEnum Question = 4
  fromCppEnum (UnknownQMessageBoxIcon n) = n
  
  toCppEnum (0) = NoIcon
  toCppEnum (1) = Information
  toCppEnum (2) = Warning
  toCppEnum (3) = Critical
  toCppEnum (4) = Question
  toCppEnum n = UnknownQMessageBoxIcon n

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

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

data QMessageBoxStandardButton =
  Ok
  | Open
  | Save
  | Cancel
  | Close
  | Discard
  | Apply
  | Reset
  | RestoreDefaults
  | Help
  | SaveAll
  | Yes
  | YesToAll
  | No
  | NoToAll
  | Abort
  | Retry
  | Ignore
  | NoButton
  | UnknownQMessageBoxStandardButton (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QMessageBoxStandardButton where
  fromCppEnum Ok = 1024
  fromCppEnum Open = 8192
  fromCppEnum Save = 2048
  fromCppEnum Cancel = 4194304
  fromCppEnum Close = 2097152
  fromCppEnum Discard = 8388608
  fromCppEnum Apply = 33554432
  fromCppEnum Reset = 67108864
  fromCppEnum RestoreDefaults = 134217728
  fromCppEnum Help = 16777216
  fromCppEnum SaveAll = 4096
  fromCppEnum Yes = 16384
  fromCppEnum YesToAll = 32768
  fromCppEnum No = 65536
  fromCppEnum NoToAll = 131072
  fromCppEnum Abort = 262144
  fromCppEnum Retry = 524288
  fromCppEnum Ignore = 1048576
  fromCppEnum NoButton = 0
  fromCppEnum (UnknownQMessageBoxStandardButton n) = n
  
  toCppEnum (0) = NoButton
  toCppEnum (1024) = Ok
  toCppEnum (2048) = Save
  toCppEnum (4096) = SaveAll
  toCppEnum (8192) = Open
  toCppEnum (16384) = Yes
  toCppEnum (32768) = YesToAll
  toCppEnum (65536) = No
  toCppEnum (131072) = NoToAll
  toCppEnum (262144) = Abort
  toCppEnum (524288) = Retry
  toCppEnum (1048576) = Ignore
  toCppEnum (2097152) = Close
  toCppEnum (4194304) = Cancel
  toCppEnum (8388608) = Discard
  toCppEnum (16777216) = Help
  toCppEnum (33554432) = Apply
  toCppEnum (67108864) = Reset
  toCppEnum (134217728) = RestoreDefaults
  toCppEnum n = UnknownQMessageBoxStandardButton n

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

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

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

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

class IsQMessageBoxStandardButtons a where
  toQMessageBoxStandardButtons :: a -> QMessageBoxStandardButtons

instance IsQMessageBoxStandardButtons QMessageBoxStandardButtons where toQMessageBoxStandardButtons = QtahP.id
instance IsQMessageBoxStandardButtons QMessageBoxStandardButton where toQMessageBoxStandardButtons = QtahFlags.enumToFlags
instance IsQMessageBoxStandardButtons (HoppyFC.CInt) where toQMessageBoxStandardButtons = QtahFlags.numToFlags

abort :: QMessageBoxStandardButtons
abort = QMessageBoxStandardButtons (262144)

apply :: QMessageBoxStandardButtons
apply = QMessageBoxStandardButtons (33554432)

cancel :: QMessageBoxStandardButtons
cancel = QMessageBoxStandardButtons (4194304)

close :: QMessageBoxStandardButtons
close = QMessageBoxStandardButtons (2097152)

discard :: QMessageBoxStandardButtons
discard = QMessageBoxStandardButtons (8388608)

help :: QMessageBoxStandardButtons
help = QMessageBoxStandardButtons (16777216)

ignore :: QMessageBoxStandardButtons
ignore = QMessageBoxStandardButtons (1048576)

no :: QMessageBoxStandardButtons
no = QMessageBoxStandardButtons (65536)

noButton :: QMessageBoxStandardButtons
noButton = QMessageBoxStandardButtons (0)

noToAll :: QMessageBoxStandardButtons
noToAll = QMessageBoxStandardButtons (131072)

ok :: QMessageBoxStandardButtons
ok = QMessageBoxStandardButtons (1024)

open :: QMessageBoxStandardButtons
open = QMessageBoxStandardButtons (8192)

reset :: QMessageBoxStandardButtons
reset = QMessageBoxStandardButtons (67108864)

restoreDefaults :: QMessageBoxStandardButtons
restoreDefaults = QMessageBoxStandardButtons (134217728)

retry :: QMessageBoxStandardButtons
retry = QMessageBoxStandardButtons (524288)

save :: QMessageBoxStandardButtons
save = QMessageBoxStandardButtons (2048)

saveAll :: QMessageBoxStandardButtons
saveAll = QMessageBoxStandardButtons (4096)

yes :: QMessageBoxStandardButtons
yes = QMessageBoxStandardButtons (16384)

yesToAll :: QMessageBoxStandardButtons
yesToAll = QMessageBoxStandardButtons (32768)

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