QLCDNumber.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QLCDNumber (
  castQLCDNumberToQFrame,
  castQFrameToQLCDNumber,
  castQLCDNumberToQWidget,
  castQWidgetToQLCDNumber,
  castQLCDNumberToQObject,
  castQObjectToQLCDNumber,
  QLCDNumberValue (..),
  QLCDNumberConstPtr (..),
  digitCount,
  mode,
  segmentStyle,
  smallDecimalPoint,
  checkOverflowInt,
  checkOverflowDouble,
  intValue,
  value,
  QLCDNumberPtr (..),
  setDigitCount,
  setMode,
  setSegmentStyle,
  setSmallDecimalPoint,
  displayDouble,
  displayInt,
  displayString,
  setBinMode,
  setDecMode,
  setHexMode,
  setOctMode,
  emitOverflow,
  QLCDNumberConst (..),
  castQLCDNumberToConst,
  QLCDNumber (..),
  castQLCDNumberToNonconst,
  new,
  newWithDigits,
  newWithDigitsAndParent,
  newWithParent,
  QLCDNumberSuper (..),
  QLCDNumberSuperConst (..),
  QLCDNumberMode (..),
  QLCDNumberSegmentStyle (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Widgets.QFrame as M400
import qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QLCDNumber_new" new' ::  HoppyP.IO (HoppyF.Ptr QLCDNumber)
foreign import ccall "genpop__QLCDNumber_newWithDigits" newWithDigits' ::  HoppyFC.CUInt -> HoppyP.IO (HoppyF.Ptr QLCDNumber)
foreign import ccall "genpop__QLCDNumber_newWithDigitsAndParent" newWithDigitsAndParent' ::  HoppyFC.CUInt -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QLCDNumber)
foreign import ccall "genpop__QLCDNumber_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QLCDNumber)
foreign import ccall "genpop__QLCDNumber_digitCount" digitCount' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLCDNumber_setDigitCount" setDigitCount' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_mode" mode' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLCDNumber_setMode" setMode' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_segmentStyle" segmentStyle' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLCDNumber_setSegmentStyle" setSegmentStyle' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_smallDecimalPoint" smallDecimalPoint' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLCDNumber_setSmallDecimalPoint" setSmallDecimalPoint' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_checkOverflowInt" checkOverflowInt' ::  HoppyF.Ptr QLCDNumberConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLCDNumber_checkOverflowDouble" checkOverflowDouble' ::  HoppyF.Ptr QLCDNumberConst -> HoppyFC.CDouble -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QLCDNumber_intValue" intValue' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QLCDNumber_value" value' ::  HoppyF.Ptr QLCDNumberConst -> HoppyP.IO HoppyFC.CDouble
foreign import ccall "genpop__QLCDNumber_displayDouble" displayDouble' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CDouble -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_displayInt" displayInt' ::  HoppyF.Ptr QLCDNumber -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_displayString" displayString' ::  HoppyF.Ptr QLCDNumber -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_setBinMode" setBinMode' ::  HoppyF.Ptr QLCDNumber -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_setDecMode" setDecMode' ::  HoppyF.Ptr QLCDNumber -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_setHexMode" setHexMode' ::  HoppyF.Ptr QLCDNumber -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_setOctMode" setOctMode' ::  HoppyF.Ptr QLCDNumber -> HoppyP.IO ()
foreign import ccall "genpop__QLCDNumber_emitOverflow" emitOverflow' ::  HoppyF.Ptr QLCDNumber -> HoppyP.IO ()
foreign import ccall "gencast__QLCDNumber__QFrame" castQLCDNumberToQFrame :: HoppyF.Ptr QLCDNumberConst -> HoppyF.Ptr M400.QFrameConst
foreign import ccall "gencast__QFrame__QLCDNumber" castQFrameToQLCDNumber :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr QLCDNumberConst
foreign import ccall "gencast__QLCDNumber__QWidget" castQLCDNumberToQWidget :: HoppyF.Ptr QLCDNumberConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QLCDNumber" castQWidgetToQLCDNumber :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QLCDNumberConst
foreign import ccall "gencast__QLCDNumber__QObject" castQLCDNumberToQObject :: HoppyF.Ptr QLCDNumberConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QLCDNumber" castQObjectToQLCDNumber :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QLCDNumberConst
foreign import ccall "gendel__QLCDNumber" delete'QLCDNumber :: HoppyF.Ptr QLCDNumberConst -> HoppyP.IO ()
foreign import ccall "&gendel__QLCDNumber" deletePtr'QLCDNumber :: HoppyF.FunPtr (HoppyF.Ptr QLCDNumberConst -> HoppyP.IO ())

class QLCDNumberValue a where
  withQLCDNumberPtr :: a -> (QLCDNumberConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QLCDNumberConstPtr a => QLCDNumberValue a where
  withQLCDNumberPtr = HoppyP.flip ($) . toQLCDNumberConst

class (M400.QFrameConstPtr this) => QLCDNumberConstPtr this where
  toQLCDNumberConst :: this -> QLCDNumberConst

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

mode :: (QLCDNumberValue this) => (this) {- ^ this -} -> (HoppyP.IO QLCDNumberMode)
mode arg'1 =
  withQLCDNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (mode' arg'1')

segmentStyle :: (QLCDNumberValue this) => (this) {- ^ this -} -> (HoppyP.IO QLCDNumberSegmentStyle)
segmentStyle arg'1 =
  withQLCDNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (segmentStyle' arg'1')

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

checkOverflowInt :: (QLCDNumberValue this) => (this) {- ^ this -} -> (HoppyP.Int) {- ^ num -} -> (HoppyP.IO HoppyP.Bool)
checkOverflowInt arg'1 arg'2 =
  withQLCDNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (checkOverflowInt' arg'1' arg'2')

checkOverflowDouble :: (QLCDNumberValue this) => (this) {- ^ this -} -> (HoppyP.Double) {- ^ num -} -> (HoppyP.IO HoppyP.Bool)
checkOverflowDouble arg'1 arg'2 =
  withQLCDNumberPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyP.realToFrac
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (checkOverflowDouble' arg'1' arg'2')

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

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

class (QLCDNumberConstPtr this, M400.QFramePtr this) => QLCDNumberPtr this where
  toQLCDNumber :: this -> QLCDNumber

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

setMode :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (QLCDNumberMode) -> (HoppyP.IO ())
setMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setMode' arg'1' arg'2')

setSegmentStyle :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (QLCDNumberSegmentStyle) -> (HoppyP.IO ())
setSegmentStyle arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setSegmentStyle' arg'1' arg'2')

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

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

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

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

setBinMode :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setBinMode arg'1 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (setBinMode' arg'1')

setDecMode :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setDecMode arg'1 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (setDecMode' arg'1')

setHexMode :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setHexMode arg'1 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (setHexMode' arg'1')

setOctMode :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
setOctMode arg'1 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (setOctMode' arg'1')

emitOverflow :: (QLCDNumberPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitOverflow arg'1 =
  HoppyFHR.withCppPtr (toQLCDNumber arg'1) $ \arg'1' ->
  (emitOverflow' arg'1')

data QLCDNumberConst =
    QLCDNumberConst (HoppyF.Ptr QLCDNumberConst)
  | QLCDNumberConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLCDNumberConst)
  deriving (HoppyP.Show)

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

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

castQLCDNumberToConst :: QLCDNumber -> QLCDNumberConst
castQLCDNumberToConst (QLCDNumber ptr') = QLCDNumberConst $ HoppyF.castPtr ptr'
castQLCDNumberToConst (QLCDNumberGc fptr' ptr') = QLCDNumberConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLCDNumberConstPtr QLCDNumberConst where
  toQLCDNumberConst = HoppyP.id

instance M400.QFrameConstPtr QLCDNumberConst where
  toQFrameConst (QLCDNumberConst ptr') = M400.QFrameConst $ castQLCDNumberToQFrame ptr'
  toQFrameConst (QLCDNumberConstGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQLCDNumberToQFrame ptr'

instance M506.QWidgetConstPtr QLCDNumberConst where
  toQWidgetConst (QLCDNumberConst ptr') = M506.QWidgetConst $ castQLCDNumberToQWidget ptr'
  toQWidgetConst (QLCDNumberConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQLCDNumberToQWidget ptr'

instance M94.QObjectConstPtr QLCDNumberConst where
  toQObjectConst (QLCDNumberConst ptr') = M94.QObjectConst $ castQLCDNumberToQObject ptr'
  toQObjectConst (QLCDNumberConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLCDNumberToQObject ptr'

data QLCDNumber =
    QLCDNumber (HoppyF.Ptr QLCDNumber)
  | QLCDNumberGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QLCDNumber)
  deriving (HoppyP.Show)

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

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

castQLCDNumberToNonconst :: QLCDNumberConst -> QLCDNumber
castQLCDNumberToNonconst (QLCDNumberConst ptr') = QLCDNumber $ HoppyF.castPtr ptr'
castQLCDNumberToNonconst (QLCDNumberConstGc fptr' ptr') = QLCDNumberGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QLCDNumberConstPtr QLCDNumber where
  toQLCDNumberConst (QLCDNumber ptr') = QLCDNumberConst $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQLCDNumberConst (QLCDNumberGc fptr' ptr') = QLCDNumberConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance QLCDNumberPtr QLCDNumber where
  toQLCDNumber = HoppyP.id

instance M400.QFrameConstPtr QLCDNumber where
  toQFrameConst (QLCDNumber ptr') = M400.QFrameConst $ castQLCDNumberToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQFrameConst (QLCDNumberGc fptr' ptr') = M400.QFrameConstGc fptr' $ castQLCDNumberToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance M400.QFramePtr QLCDNumber where
  toQFrame (QLCDNumber ptr') = M400.QFrame $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQLCDNumberToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQFrame (QLCDNumberGc fptr' ptr') = M400.QFrameGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M400.QFrameConst -> HoppyF.Ptr M400.QFrame) $ castQLCDNumberToQFrame $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance M506.QWidgetConstPtr QLCDNumber where
  toQWidgetConst (QLCDNumber ptr') = M506.QWidgetConst $ castQLCDNumberToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQWidgetConst (QLCDNumberGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQLCDNumberToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance M506.QWidgetPtr QLCDNumber where
  toQWidget (QLCDNumber ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQLCDNumberToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQWidget (QLCDNumberGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQLCDNumberToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance M94.QObjectConstPtr QLCDNumber where
  toQObjectConst (QLCDNumber ptr') = M94.QObjectConst $ castQLCDNumberToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQObjectConst (QLCDNumberGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQLCDNumberToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

instance M94.QObjectPtr QLCDNumber where
  toQObject (QLCDNumber ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLCDNumberToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'
  toQObject (QLCDNumberGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQLCDNumberToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QLCDNumber -> HoppyF.Ptr QLCDNumberConst) ptr'

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

newWithDigits :: (HoppyFC.CUInt) {- ^ numDigits -} -> (HoppyP.IO QLCDNumber)
newWithDigits arg'1 =
  let arg'1' = arg'1 in
  HoppyP.fmap QLCDNumber
  (newWithDigits' arg'1')

newWithDigitsAndParent :: (M506.QWidgetPtr parent) => (HoppyFC.CUInt) {- ^ numDigits -} -> (parent) {- ^ parent -} -> (HoppyP.IO QLCDNumber)
newWithDigitsAndParent arg'1 arg'2 =
  let arg'1' = arg'1 in
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap QLCDNumber
  (newWithDigitsAndParent' arg'1' arg'2')

newWithParent :: (M506.QWidgetPtr parent) => (parent) {- ^ parent -} -> (HoppyP.IO QLCDNumber)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M506.toQWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QLCDNumber
  (newWithParent' arg'1')

class QLCDNumberSuper a where
  downToQLCDNumber :: a -> QLCDNumber

instance QLCDNumberSuper M400.QFrame where
  downToQLCDNumber = castQLCDNumberToNonconst . cast' . M400.castQFrameToConst
    where
      cast' (M400.QFrameConst ptr') = QLCDNumberConst $ castQFrameToQLCDNumber ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQFrameToQLCDNumber ptr'
instance QLCDNumberSuper M506.QWidget where
  downToQLCDNumber = castQLCDNumberToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QLCDNumberConst $ castQWidgetToQLCDNumber ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQWidgetToQLCDNumber ptr'
instance QLCDNumberSuper M94.QObject where
  downToQLCDNumber = castQLCDNumberToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QLCDNumberConst $ castQObjectToQLCDNumber ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQObjectToQLCDNumber ptr'

class QLCDNumberSuperConst a where
  downToQLCDNumberConst :: a -> QLCDNumberConst

instance QLCDNumberSuperConst M400.QFrameConst where
  downToQLCDNumberConst = cast'
    where
      cast' (M400.QFrameConst ptr') = QLCDNumberConst $ castQFrameToQLCDNumber ptr'
      cast' (M400.QFrameConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQFrameToQLCDNumber ptr'
instance QLCDNumberSuperConst M506.QWidgetConst where
  downToQLCDNumberConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QLCDNumberConst $ castQWidgetToQLCDNumber ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQWidgetToQLCDNumber ptr'
instance QLCDNumberSuperConst M94.QObjectConst where
  downToQLCDNumberConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QLCDNumberConst $ castQObjectToQLCDNumber ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QLCDNumberConstGc fptr' $ castQObjectToQLCDNumber ptr'

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

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

data QLCDNumberMode =
  Hex
  | Dec
  | Bin
  | Oct
  | UnknownQlcdNumberMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLCDNumberMode where
  fromCppEnum Hex = 0
  fromCppEnum Dec = 1
  fromCppEnum Bin = 3
  fromCppEnum Oct = 2
  fromCppEnum (UnknownQlcdNumberMode n) = n
  
  toCppEnum (0) = Hex
  toCppEnum (1) = Dec
  toCppEnum (2) = Oct
  toCppEnum (3) = Bin
  toCppEnum n = UnknownQlcdNumberMode n

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

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

data QLCDNumberSegmentStyle =
  Outline
  | Filled
  | Flat
  | UnknownQlcdNumberSegmentStyle (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QLCDNumberSegmentStyle where
  fromCppEnum Outline = 0
  fromCppEnum Filled = 1
  fromCppEnum Flat = 2
  fromCppEnum (UnknownQlcdNumberSegmentStyle n) = n
  
  toCppEnum (0) = Outline
  toCppEnum (1) = Filled
  toCppEnum (2) = Flat
  toCppEnum n = UnknownQlcdNumberSegmentStyle n

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

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