QAbstractSpinBox.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QAbstractSpinBox (
  castQAbstractSpinBoxToQWidget,
  castQWidgetToQAbstractSpinBox,
  castQAbstractSpinBoxToQObject,
  castQObjectToQAbstractSpinBox,
  QAbstractSpinBoxValue (..),
  QAbstractSpinBoxConstPtr (..),
  isAccelerated,
  alignment,
  buttonSymbols,
  correctionMode,
  hasAcceptableInput,
  fixup,
  hasFrame,
  isGroupSeparatorShown,
  keyboardTracking,
  isReadOnly,
  specialValueText,
  text,
  wrapping,
  QAbstractSpinBoxPtr (..),
  setAccelerated,
  setAlignment,
  setButtonSymbols,
  clear,
  setCorrectionMode,
  setFrame,
  setGroupSeparatorShown,
  interpretText,
  setKeyboardTracking,
  setReadOnly,
  selectAll,
  setSpecialValueText,
  stepBy,
  stepDown,
  stepUp,
  setWrapping,
  emitEditingFinished,
  QAbstractSpinBoxConst (..),
  castQAbstractSpinBoxToConst,
  QAbstractSpinBox (..),
  castQAbstractSpinBoxToNonconst,
  new,
  newWithParent,
  QAbstractSpinBoxSuper (..),
  QAbstractSpinBoxSuperConst (..),
  QAbstractSpinBoxButtonSymbols (..),
  QAbstractSpinBoxCorrectionMode (..),
  QAbstractSpinBoxStepEnabled,
  IsQAbstractSpinBoxStepEnabled (..),
  stepDownEnabled,
  stepNone,
  stepUpEnabled,
  QAbstractSpinBoxStepEnabledFlag (..),
  ) 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.Types as M190
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__QAbstractSpinBox_new" new' ::  HoppyP.IO (HoppyF.Ptr QAbstractSpinBox)
foreign import ccall "genpop__QAbstractSpinBox_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QAbstractSpinBox)
foreign import ccall "genpop__QAbstractSpinBox_isAccelerated" isAccelerated' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setAccelerated" setAccelerated' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_alignment" alignment' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractSpinBox_setAlignment" setAlignment' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_buttonSymbols" buttonSymbols' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractSpinBox_setButtonSymbols" setButtonSymbols' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_clear" clear' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_correctionMode" correctionMode' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QAbstractSpinBox_setCorrectionMode" setCorrectionMode' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_hasAcceptableInput" hasAcceptableInput' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_fixup" fixup' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyF.Ptr M142.QString -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_hasFrame" hasFrame' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setFrame" setFrame' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_isGroupSeparatorShown" isGroupSeparatorShown' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setGroupSeparatorShown" setGroupSeparatorShown' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_interpretText" interpretText' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_keyboardTracking" keyboardTracking' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setKeyboardTracking" setKeyboardTracking' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_isReadOnly" isReadOnly' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setReadOnly" setReadOnly' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_selectAll" selectAll' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_specialValueText" specialValueText' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QAbstractSpinBox_setSpecialValueText" setSpecialValueText' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_stepBy" stepBy' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_stepDown" stepDown' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_stepUp" stepUp' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_text" text' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QAbstractSpinBox_wrapping" wrapping' ::  HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QAbstractSpinBox_setWrapping" setWrapping' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QAbstractSpinBox_emitEditingFinished" emitEditingFinished' ::  HoppyF.Ptr QAbstractSpinBox -> HoppyP.IO ()
foreign import ccall "gencast__QAbstractSpinBox__QWidget" castQAbstractSpinBoxToQWidget :: HoppyF.Ptr QAbstractSpinBoxConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QAbstractSpinBox" castQWidgetToQAbstractSpinBox :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QAbstractSpinBoxConst
foreign import ccall "gencast__QAbstractSpinBox__QObject" castQAbstractSpinBoxToQObject :: HoppyF.Ptr QAbstractSpinBoxConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QAbstractSpinBox" castQObjectToQAbstractSpinBox :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QAbstractSpinBoxConst
foreign import ccall "gendel__QAbstractSpinBox" delete'QAbstractSpinBox :: HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO ()
foreign import ccall "&gendel__QAbstractSpinBox" deletePtr'QAbstractSpinBox :: HoppyF.FunPtr (HoppyF.Ptr QAbstractSpinBoxConst -> HoppyP.IO ())

class QAbstractSpinBoxValue a where
  withQAbstractSpinBoxPtr :: a -> (QAbstractSpinBoxConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QAbstractSpinBoxConstPtr a => QAbstractSpinBoxValue a where
  withQAbstractSpinBoxPtr = HoppyP.flip ($) . toQAbstractSpinBoxConst

class (M506.QWidgetConstPtr this) => QAbstractSpinBoxConstPtr this where
  toQAbstractSpinBoxConst :: this -> QAbstractSpinBoxConst

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

alignment :: (QAbstractSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtAlignment)
alignment arg'1 =
  withQAbstractSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (alignment' arg'1')

buttonSymbols :: (QAbstractSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QAbstractSpinBoxButtonSymbols)
buttonSymbols arg'1 =
  withQAbstractSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (buttonSymbols' arg'1')

correctionMode :: (QAbstractSpinBoxValue this) => (this) {- ^ this -} -> (HoppyP.IO QAbstractSpinBoxCorrectionMode)
correctionMode arg'1 =
  withQAbstractSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (correctionMode' arg'1')

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

fixup :: (QAbstractSpinBoxValue this, M142.QStringPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
fixup arg'1 arg'2 =
  withQAbstractSpinBoxPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M142.toQString arg'2) $ \arg'2' ->
  (fixup' arg'1' arg'2')

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

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

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

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

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

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

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

class (QAbstractSpinBoxConstPtr this, M506.QWidgetPtr this) => QAbstractSpinBoxPtr this where
  toQAbstractSpinBox :: this -> QAbstractSpinBox

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

setAlignment :: (QAbstractSpinBoxPtr this, M190.IsQtAlignment arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setAlignment arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtAlignment
  ) arg'2 >>= \arg'2' ->
  (setAlignment' arg'1' arg'2')

setButtonSymbols :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (QAbstractSpinBoxButtonSymbols) -> (HoppyP.IO ())
setButtonSymbols arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setButtonSymbols' arg'1' arg'2')

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

setCorrectionMode :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (QAbstractSpinBoxCorrectionMode) -> (HoppyP.IO ())
setCorrectionMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setCorrectionMode' arg'1' arg'2')

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

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

interpretText :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
interpretText arg'1 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (interpretText' arg'1')

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

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

selectAll :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
selectAll arg'1 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (selectAll' arg'1')

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

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

stepDown :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
stepDown arg'1 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (stepDown' arg'1')

stepUp :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
stepUp arg'1 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (stepUp' arg'1')

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

emitEditingFinished :: (QAbstractSpinBoxPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitEditingFinished arg'1 =
  HoppyFHR.withCppPtr (toQAbstractSpinBox arg'1) $ \arg'1' ->
  (emitEditingFinished' arg'1')

data QAbstractSpinBoxConst =
    QAbstractSpinBoxConst (HoppyF.Ptr QAbstractSpinBoxConst)
  | QAbstractSpinBoxConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAbstractSpinBoxConst)
  deriving (HoppyP.Show)

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

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

castQAbstractSpinBoxToConst :: QAbstractSpinBox -> QAbstractSpinBoxConst
castQAbstractSpinBoxToConst (QAbstractSpinBox ptr') = QAbstractSpinBoxConst $ HoppyF.castPtr ptr'
castQAbstractSpinBoxToConst (QAbstractSpinBoxGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAbstractSpinBoxConstPtr QAbstractSpinBoxConst where
  toQAbstractSpinBoxConst = HoppyP.id

instance M506.QWidgetConstPtr QAbstractSpinBoxConst where
  toQWidgetConst (QAbstractSpinBoxConst ptr') = M506.QWidgetConst $ castQAbstractSpinBoxToQWidget ptr'
  toQWidgetConst (QAbstractSpinBoxConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQAbstractSpinBoxToQWidget ptr'

instance M94.QObjectConstPtr QAbstractSpinBoxConst where
  toQObjectConst (QAbstractSpinBoxConst ptr') = M94.QObjectConst $ castQAbstractSpinBoxToQObject ptr'
  toQObjectConst (QAbstractSpinBoxConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAbstractSpinBoxToQObject ptr'

data QAbstractSpinBox =
    QAbstractSpinBox (HoppyF.Ptr QAbstractSpinBox)
  | QAbstractSpinBoxGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QAbstractSpinBox)
  deriving (HoppyP.Show)

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

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

castQAbstractSpinBoxToNonconst :: QAbstractSpinBoxConst -> QAbstractSpinBox
castQAbstractSpinBoxToNonconst (QAbstractSpinBoxConst ptr') = QAbstractSpinBox $ HoppyF.castPtr ptr'
castQAbstractSpinBoxToNonconst (QAbstractSpinBoxConstGc fptr' ptr') = QAbstractSpinBoxGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QAbstractSpinBoxConstPtr QAbstractSpinBox where
  toQAbstractSpinBoxConst (QAbstractSpinBox ptr') = QAbstractSpinBoxConst $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'
  toQAbstractSpinBoxConst (QAbstractSpinBoxGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'

instance QAbstractSpinBoxPtr QAbstractSpinBox where
  toQAbstractSpinBox = HoppyP.id

instance M506.QWidgetConstPtr QAbstractSpinBox where
  toQWidgetConst (QAbstractSpinBox ptr') = M506.QWidgetConst $ castQAbstractSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'
  toQWidgetConst (QAbstractSpinBoxGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQAbstractSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'

instance M506.QWidgetPtr QAbstractSpinBox where
  toQWidget (QAbstractSpinBox ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQAbstractSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'
  toQWidget (QAbstractSpinBoxGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQAbstractSpinBoxToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'

instance M94.QObjectConstPtr QAbstractSpinBox where
  toQObjectConst (QAbstractSpinBox ptr') = M94.QObjectConst $ castQAbstractSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'
  toQObjectConst (QAbstractSpinBoxGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQAbstractSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'

instance M94.QObjectPtr QAbstractSpinBox where
  toQObject (QAbstractSpinBox ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAbstractSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'
  toQObject (QAbstractSpinBoxGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQAbstractSpinBoxToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QAbstractSpinBox -> HoppyF.Ptr QAbstractSpinBoxConst) ptr'

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

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

class QAbstractSpinBoxSuper a where
  downToQAbstractSpinBox :: a -> QAbstractSpinBox

instance QAbstractSpinBoxSuper M506.QWidget where
  downToQAbstractSpinBox = castQAbstractSpinBoxToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QAbstractSpinBoxConst $ castQWidgetToQAbstractSpinBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ castQWidgetToQAbstractSpinBox ptr'
instance QAbstractSpinBoxSuper M94.QObject where
  downToQAbstractSpinBox = castQAbstractSpinBoxToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QAbstractSpinBoxConst $ castQObjectToQAbstractSpinBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ castQObjectToQAbstractSpinBox ptr'

class QAbstractSpinBoxSuperConst a where
  downToQAbstractSpinBoxConst :: a -> QAbstractSpinBoxConst

instance QAbstractSpinBoxSuperConst M506.QWidgetConst where
  downToQAbstractSpinBoxConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QAbstractSpinBoxConst $ castQWidgetToQAbstractSpinBox ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ castQWidgetToQAbstractSpinBox ptr'
instance QAbstractSpinBoxSuperConst M94.QObjectConst where
  downToQAbstractSpinBoxConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QAbstractSpinBoxConst $ castQObjectToQAbstractSpinBox ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QAbstractSpinBoxConstGc fptr' $ castQObjectToQAbstractSpinBox ptr'

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

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

data QAbstractSpinBoxButtonSymbols =
  UpDownArrows
  | PlusMinus
  | NoButtons
  | UnknownQAbstractSpinBoxButtonSymbols (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractSpinBoxButtonSymbols where
  fromCppEnum UpDownArrows = 0
  fromCppEnum PlusMinus = 1
  fromCppEnum NoButtons = 2
  fromCppEnum (UnknownQAbstractSpinBoxButtonSymbols n) = n
  
  toCppEnum (0) = UpDownArrows
  toCppEnum (1) = PlusMinus
  toCppEnum (2) = NoButtons
  toCppEnum n = UnknownQAbstractSpinBoxButtonSymbols n

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

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

data QAbstractSpinBoxCorrectionMode =
  CorrectToPreviousValue
  | CorrectToNearestValue
  | UnknownQAbstractSpinBoxCorrectionMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractSpinBoxCorrectionMode where
  fromCppEnum CorrectToPreviousValue = 0
  fromCppEnum CorrectToNearestValue = 1
  fromCppEnum (UnknownQAbstractSpinBoxCorrectionMode n) = n
  
  toCppEnum (0) = CorrectToPreviousValue
  toCppEnum (1) = CorrectToNearestValue
  toCppEnum n = UnknownQAbstractSpinBoxCorrectionMode n

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

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

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

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

class IsQAbstractSpinBoxStepEnabled a where
  toQAbstractSpinBoxStepEnabled :: a -> QAbstractSpinBoxStepEnabled

instance IsQAbstractSpinBoxStepEnabled QAbstractSpinBoxStepEnabled where toQAbstractSpinBoxStepEnabled = QtahP.id
instance IsQAbstractSpinBoxStepEnabled QAbstractSpinBoxStepEnabledFlag where toQAbstractSpinBoxStepEnabled = QtahFlags.enumToFlags
instance IsQAbstractSpinBoxStepEnabled (HoppyFC.CInt) where toQAbstractSpinBoxStepEnabled = QtahFlags.numToFlags

stepDownEnabled :: QAbstractSpinBoxStepEnabled
stepDownEnabled = QAbstractSpinBoxStepEnabled (2)

stepNone :: QAbstractSpinBoxStepEnabled
stepNone = QAbstractSpinBoxStepEnabled (0)

stepUpEnabled :: QAbstractSpinBoxStepEnabled
stepUpEnabled = QAbstractSpinBoxStepEnabled (1)

instance QtahDB.Bits QAbstractSpinBoxStepEnabled 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 QAbstractSpinBoxStepEnabledFlag =
  StepNone
  | StepUpEnabled
  | StepDownEnabled
  | UnknownQAbstractSpinBoxStepEnabledFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QAbstractSpinBoxStepEnabledFlag where
  fromCppEnum StepNone = 0
  fromCppEnum StepUpEnabled = 1
  fromCppEnum StepDownEnabled = 2
  fromCppEnum (UnknownQAbstractSpinBoxStepEnabledFlag n) = n
  
  toCppEnum (0) = StepNone
  toCppEnum (1) = StepUpEnabled
  toCppEnum (2) = StepDownEnabled
  toCppEnum n = UnknownQAbstractSpinBoxStepEnabledFlag n

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

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