QSizePolicy.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QSizePolicy (
  QSizePolicyValue (..),
  QSizePolicyConstPtr (..),
  controlType,
  expandingDirections,
  hasHeightForWidth,
  hasWidthForHeight,
  horizontalPolicy,
  horizontalStretch,
  verticalPolicy,
  verticalStretch,
  retainSizeWhenHidden,
  eQ,
  nE,
  QSizePolicyPtr (..),
  setControlType,
  setHeightForWidth,
  setWidthForHeight,
  setHorizontalPolicy,
  setHorizontalStretch,
  setVerticalPolicy,
  setVerticalStretch,
  setRetainSizeWhenHidden,
  transpose,
  QSizePolicyConst (..),
  castQSizePolicyToConst,
  QSizePolicy (..),
  castQSizePolicyToNonconst,
  new,
  newWithOptions,
  newCopy,
  QSizePolicySuper (..),
  QSizePolicySuperConst (..),
  QSizePolicyControlType (..),
  QSizePolicyControlTypes,
  IsQSizePolicyControlTypes (..),
  buttonBox,
  checkBox,
  comboBox,
  defaultType,
  frame,
  groupBox,
  label,
  line,
  lineEdit,
  pushButton,
  radioButton,
  slider,
  spinBox,
  tabWidget,
  toolButton,
  QSizePolicyPolicy (..),
  QSizePolicyPolicyFlag (..),
  ) where

import Control.Monad ((>=>))
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.Types as M190
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QSizePolicy_new" new' ::  HoppyP.IO (HoppyF.Ptr QSizePolicy)
foreign import ccall "genpop__QSizePolicy_newWithOptions" newWithOptions' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QSizePolicy)
foreign import ccall "genpop__QSizePolicy_newCopy" newCopy' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO (HoppyF.Ptr QSizePolicy)
foreign import ccall "genpop__QSizePolicy_controlType" controlType' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_setControlType" setControlType' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_expandingDirections" expandingDirections' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_hasHeightForWidth" hasHeightForWidth' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSizePolicy_setHeightForWidth" setHeightForWidth' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_hasWidthForHeight" hasWidthForHeight' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSizePolicy_setWidthForHeight" setWidthForHeight' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_horizontalPolicy" horizontalPolicy' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_setHorizontalPolicy" setHorizontalPolicy' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_horizontalStretch" horizontalStretch' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_setHorizontalStretch" setHorizontalStretch' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_verticalPolicy" verticalPolicy' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_setVerticalPolicy" setVerticalPolicy' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_verticalStretch" verticalStretch' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QSizePolicy_setVerticalStretch" setVerticalStretch' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_retainSizeWhenHidden" retainSizeWhenHidden' ::  HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSizePolicy_setRetainSizeWhenHidden" setRetainSizeWhenHidden' ::  HoppyF.Ptr QSizePolicy -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_transpose" transpose' ::  HoppyF.Ptr QSizePolicy -> HoppyP.IO ()
foreign import ccall "genpop__QSizePolicy_EQ" eQ' ::  HoppyF.Ptr QSizePolicyConst -> HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSizePolicy_NE" nE' ::  HoppyF.Ptr QSizePolicyConst -> HoppyF.Ptr QSizePolicyConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "gendel__QSizePolicy" delete'QSizePolicy :: HoppyF.Ptr QSizePolicyConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSizePolicy" deletePtr'QSizePolicy :: HoppyF.FunPtr (HoppyF.Ptr QSizePolicyConst -> HoppyP.IO ())

class QSizePolicyValue a where
  withQSizePolicyPtr :: a -> (QSizePolicyConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QSizePolicyConstPtr a => QSizePolicyValue a where
  withQSizePolicyPtr = HoppyP.flip ($) . toQSizePolicyConst

class (HoppyFHR.CppPtr this) => QSizePolicyConstPtr this where
  toQSizePolicyConst :: this -> QSizePolicyConst

controlType :: (QSizePolicyValue this) => (this) {- ^ this -} -> (HoppyP.IO QSizePolicyControlType)
controlType arg'1 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (controlType' arg'1')

expandingDirections :: (QSizePolicyValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtOrientations)
expandingDirections arg'1 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (expandingDirections' arg'1')

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

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

horizontalPolicy :: (QSizePolicyValue this) => (this) {- ^ this -} -> (HoppyP.IO QSizePolicyPolicy)
horizontalPolicy arg'1 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (horizontalPolicy' arg'1')

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

verticalPolicy :: (QSizePolicyValue this) => (this) {- ^ this -} -> (HoppyP.IO QSizePolicyPolicy)
verticalPolicy arg'1 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (verticalPolicy' arg'1')

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

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

eQ :: (QSizePolicyValue this, QSizePolicyValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
eQ arg'1 arg'2 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQSizePolicyPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (eQ' arg'1' arg'2')

nE :: (QSizePolicyValue this, QSizePolicyValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO HoppyP.Bool)
nE arg'1 arg'2 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  withQSizePolicyPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (nE' arg'1' arg'2')

class (QSizePolicyConstPtr this) => QSizePolicyPtr this where
  toQSizePolicy :: this -> QSizePolicy

setControlType :: (QSizePolicyPtr this) => (this) {- ^ this -} -> (QSizePolicyControlType) -> (HoppyP.IO ())
setControlType arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSizePolicy arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setControlType' arg'1' arg'2')

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

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

setHorizontalPolicy :: (QSizePolicyPtr this) => (this) {- ^ this -} -> (QSizePolicyPolicy) -> (HoppyP.IO ())
setHorizontalPolicy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSizePolicy arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setHorizontalPolicy' arg'1' arg'2')

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

setVerticalPolicy :: (QSizePolicyPtr this) => (this) {- ^ this -} -> (QSizePolicyPolicy) -> (HoppyP.IO ())
setVerticalPolicy arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSizePolicy arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setVerticalPolicy' arg'1' arg'2')

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

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

transpose :: (QSizePolicyPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
transpose arg'1 =
  HoppyFHR.withCppPtr (toQSizePolicy arg'1) $ \arg'1' ->
  (transpose' arg'1')

data QSizePolicyConst =
    QSizePolicyConst (HoppyF.Ptr QSizePolicyConst)
  | QSizePolicyConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSizePolicyConst)
  deriving (HoppyP.Show)

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

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

castQSizePolicyToConst :: QSizePolicy -> QSizePolicyConst
castQSizePolicyToConst (QSizePolicy ptr') = QSizePolicyConst $ HoppyF.castPtr ptr'
castQSizePolicyToConst (QSizePolicyGc fptr' ptr') = QSizePolicyConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QSizePolicyConst QSizePolicy where copy = newCopy

instance QSizePolicyConstPtr QSizePolicyConst where
  toQSizePolicyConst = HoppyP.id

data QSizePolicy =
    QSizePolicy (HoppyF.Ptr QSizePolicy)
  | QSizePolicyGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSizePolicy)
  deriving (HoppyP.Show)

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

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

castQSizePolicyToNonconst :: QSizePolicyConst -> QSizePolicy
castQSizePolicyToNonconst (QSizePolicyConst ptr') = QSizePolicy $ HoppyF.castPtr ptr'
castQSizePolicyToNonconst (QSizePolicyConstGc fptr' ptr') = QSizePolicyGc fptr' $ HoppyF.castPtr ptr'

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

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

instance HoppyFHR.Copyable QSizePolicy QSizePolicy where copy = newCopy

instance QSizePolicyConstPtr QSizePolicy where
  toQSizePolicyConst (QSizePolicy ptr') = QSizePolicyConst $ (HoppyF.castPtr :: HoppyF.Ptr QSizePolicy -> HoppyF.Ptr QSizePolicyConst) ptr'
  toQSizePolicyConst (QSizePolicyGc fptr' ptr') = QSizePolicyConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSizePolicy -> HoppyF.Ptr QSizePolicyConst) ptr'

instance QSizePolicyPtr QSizePolicy where
  toQSizePolicy = HoppyP.id

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

newWithOptions :: (QSizePolicyPolicy) -> (QSizePolicyPolicy) -> (QSizePolicyControlType) -> (HoppyP.IO QSizePolicy)
newWithOptions arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QSizePolicy
  (newWithOptions' arg'1' arg'2' arg'3')

newCopy :: (QSizePolicyValue arg'1) => (arg'1) -> (HoppyP.IO QSizePolicy)
newCopy arg'1 =
  withQSizePolicyPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QSizePolicy
  (newCopy' arg'1')

class QSizePolicySuper a where
  downToQSizePolicy :: a -> QSizePolicy


class QSizePolicySuperConst a where
  downToQSizePolicyConst :: a -> QSizePolicyConst


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

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

instance HoppyFHR.Decodable QSizePolicy (QSizePolicy) where
  decode = HoppyFHR.decode . toQSizePolicyConst

instance HoppyFHR.Decodable QSizePolicyConst (QSizePolicy) where
  decode =
    HoppyFHR.copy >=> HoppyFHR.toGc

data QSizePolicyControlType =
  DefaultType
  | ButtonBox
  | CheckBox
  | ComboBox
  | Frame
  | GroupBox
  | Label
  | Line
  | LineEdit
  | PushButton
  | RadioButton
  | Slider
  | SpinBox
  | TabWidget
  | ToolButton
  | UnknownQSizePolicyControlType (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSizePolicyControlType where
  fromCppEnum DefaultType = 1
  fromCppEnum ButtonBox = 2
  fromCppEnum CheckBox = 4
  fromCppEnum ComboBox = 8
  fromCppEnum Frame = 16
  fromCppEnum GroupBox = 32
  fromCppEnum Label = 64
  fromCppEnum Line = 128
  fromCppEnum LineEdit = 256
  fromCppEnum PushButton = 512
  fromCppEnum RadioButton = 1024
  fromCppEnum Slider = 2048
  fromCppEnum SpinBox = 4096
  fromCppEnum TabWidget = 8192
  fromCppEnum ToolButton = 16384
  fromCppEnum (UnknownQSizePolicyControlType n) = n
  
  toCppEnum (1) = DefaultType
  toCppEnum (2) = ButtonBox
  toCppEnum (4) = CheckBox
  toCppEnum (8) = ComboBox
  toCppEnum (16) = Frame
  toCppEnum (32) = GroupBox
  toCppEnum (64) = Label
  toCppEnum (128) = Line
  toCppEnum (256) = LineEdit
  toCppEnum (512) = PushButton
  toCppEnum (1024) = RadioButton
  toCppEnum (2048) = Slider
  toCppEnum (4096) = SpinBox
  toCppEnum (8192) = TabWidget
  toCppEnum (16384) = ToolButton
  toCppEnum n = UnknownQSizePolicyControlType n

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

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

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

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

class IsQSizePolicyControlTypes a where
  toQSizePolicyControlTypes :: a -> QSizePolicyControlTypes

instance IsQSizePolicyControlTypes QSizePolicyControlTypes where toQSizePolicyControlTypes = QtahP.id
instance IsQSizePolicyControlTypes QSizePolicyControlType where toQSizePolicyControlTypes = QtahFlags.enumToFlags
instance IsQSizePolicyControlTypes (HoppyFC.CInt) where toQSizePolicyControlTypes = QtahFlags.numToFlags

buttonBox :: QSizePolicyControlTypes
buttonBox = QSizePolicyControlTypes (2)

checkBox :: QSizePolicyControlTypes
checkBox = QSizePolicyControlTypes (4)

comboBox :: QSizePolicyControlTypes
comboBox = QSizePolicyControlTypes (8)

defaultType :: QSizePolicyControlTypes
defaultType = QSizePolicyControlTypes (1)

frame :: QSizePolicyControlTypes
frame = QSizePolicyControlTypes (16)

groupBox :: QSizePolicyControlTypes
groupBox = QSizePolicyControlTypes (32)

label :: QSizePolicyControlTypes
label = QSizePolicyControlTypes (64)

line :: QSizePolicyControlTypes
line = QSizePolicyControlTypes (128)

lineEdit :: QSizePolicyControlTypes
lineEdit = QSizePolicyControlTypes (256)

pushButton :: QSizePolicyControlTypes
pushButton = QSizePolicyControlTypes (512)

radioButton :: QSizePolicyControlTypes
radioButton = QSizePolicyControlTypes (1024)

slider :: QSizePolicyControlTypes
slider = QSizePolicyControlTypes (2048)

spinBox :: QSizePolicyControlTypes
spinBox = QSizePolicyControlTypes (4096)

tabWidget :: QSizePolicyControlTypes
tabWidget = QSizePolicyControlTypes (8192)

toolButton :: QSizePolicyControlTypes
toolButton = QSizePolicyControlTypes (16384)

instance QtahDB.Bits QSizePolicyControlTypes 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 QSizePolicyPolicy =
  Fixed
  | Minimum
  | Maximum
  | Preferred
  | Expanding
  | MinimumExpanding
  | Ignored
  | UnknownQSizePolicyPolicy (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSizePolicyPolicy where
  fromCppEnum Fixed = 0
  fromCppEnum Minimum = 1
  fromCppEnum Maximum = 4
  fromCppEnum Preferred = 5
  fromCppEnum Expanding = 7
  fromCppEnum MinimumExpanding = 3
  fromCppEnum Ignored = 13
  fromCppEnum (UnknownQSizePolicyPolicy n) = n
  
  toCppEnum (0) = Fixed
  toCppEnum (1) = Minimum
  toCppEnum (3) = MinimumExpanding
  toCppEnum (4) = Maximum
  toCppEnum (5) = Preferred
  toCppEnum (7) = Expanding
  toCppEnum (13) = Ignored
  toCppEnum n = UnknownQSizePolicyPolicy n

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

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

data QSizePolicyPolicyFlag =
  GrowFlag
  | ExpandFlag
  | ShrinkFlag
  | IgnoreFlag
  | UnknownQSizePolicyPolicyFlag (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSizePolicyPolicyFlag where
  fromCppEnum GrowFlag = 1
  fromCppEnum ExpandFlag = 2
  fromCppEnum ShrinkFlag = 4
  fromCppEnum IgnoreFlag = 8
  fromCppEnum (UnknownQSizePolicyPolicyFlag n) = n
  
  toCppEnum (1) = GrowFlag
  toCppEnum (2) = ExpandFlag
  toCppEnum (4) = ShrinkFlag
  toCppEnum (8) = IgnoreFlag
  toCppEnum n = UnknownQSizePolicyPolicyFlag n

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

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