QFrame.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QFrame (
  castQFrameToQWidget,
  castQWidgetToQFrame,
  castQFrameToQObject,
  castQObjectToQFrame,
  QFrameValue (..),
  QFrameConstPtr (..),
  frameRect,
  frameShadow,
  frameShape,
  frameStyle,
  frameWidth,
  lineWidth,
  midLineWidth,
  QFramePtr (..),
  setFrameRect,
  setFrameShadow,
  setFrameShape,
  setFrameStyle,
  setLineWidth,
  setMidLineWidth,
  QFrameConst (..),
  castQFrameToConst,
  QFrame (..),
  castQFrameToNonconst,
  new,
  newWithParent,
  QFrameSuper (..),
  QFrameSuperConst (..),
  QFrameShadow (..),
  QFrameShape (..),
  QFrameStyleMask (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Core.HRect as HRect
import qualified Graphics.UI.Qtah.Generated.Core.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QRect as M122
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QWidget as M506
import Prelude (($), (.), (=<<), (==), (>>=))
import qualified Prelude as HoppyP

foreign import ccall "genpop__QFrame_new" new' ::  HoppyP.IO (HoppyF.Ptr QFrame)
foreign import ccall "genpop__QFrame_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QFrame)
foreign import ccall "genpop__QFrame_frameRect" frameRect' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QFrame_setFrameRect" setFrameRect' ::  HoppyF.Ptr QFrame -> HoppyF.Ptr M122.QRectConst -> HoppyP.IO ()
foreign import ccall "genpop__QFrame_frameShadow" frameShadow' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_setFrameShadow" setFrameShadow' ::  HoppyF.Ptr QFrame -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QFrame_frameShape" frameShape' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_setFrameShape" setFrameShape' ::  HoppyF.Ptr QFrame -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QFrame_frameStyle" frameStyle' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_setFrameStyle" setFrameStyle' ::  HoppyF.Ptr QFrame -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QFrame_frameWidth" frameWidth' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_lineWidth" lineWidth' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_setLineWidth" setLineWidth' ::  HoppyF.Ptr QFrame -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QFrame_midLineWidth" midLineWidth' ::  HoppyF.Ptr QFrameConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QFrame_setMidLineWidth" setMidLineWidth' ::  HoppyF.Ptr QFrame -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "gencast__QFrame__QWidget" castQFrameToQWidget :: HoppyF.Ptr QFrameConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QFrame" castQWidgetToQFrame :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QFrameConst
foreign import ccall "gencast__QFrame__QObject" castQFrameToQObject :: HoppyF.Ptr QFrameConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QFrame" castQObjectToQFrame :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QFrameConst
foreign import ccall "gendel__QFrame" delete'QFrame :: HoppyF.Ptr QFrameConst -> HoppyP.IO ()
foreign import ccall "&gendel__QFrame" deletePtr'QFrame :: HoppyF.FunPtr (HoppyF.Ptr QFrameConst -> HoppyP.IO ())

class QFrameValue a where
  withQFramePtr :: a -> (QFrameConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QFrameConstPtr a => QFrameValue a where
  withQFramePtr = HoppyP.flip ($) . toQFrameConst

class (M506.QWidgetConstPtr this) => QFrameConstPtr this where
  toQFrameConst :: this -> QFrameConst

frameRect :: (QFrameValue this) => (this) {- ^ this -} -> (HoppyP.IO HRect.HRect)
frameRect arg'1 =
  withQFramePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M122.QRectConst) =<<
  (frameRect' arg'1')

frameShadow :: (QFrameValue this) => (this) {- ^ this -} -> (HoppyP.IO QFrameShadow)
frameShadow arg'1 =
  withQFramePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (frameShadow' arg'1')

frameShape :: (QFrameValue this) => (this) {- ^ this -} -> (HoppyP.IO QFrameShape)
frameShape arg'1 =
  withQFramePtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (frameShape' arg'1')

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

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

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

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

class (QFrameConstPtr this, M506.QWidgetPtr this) => QFramePtr this where
  toQFrame :: this -> QFrame

setFrameRect :: (QFramePtr this, M122.QRectValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFrameRect arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFrame arg'1) $ \arg'1' ->
  M122.withQRectPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFrameRect' arg'1' arg'2')

setFrameShadow :: (QFramePtr this) => (this) {- ^ this -} -> (QFrameShadow) -> (HoppyP.IO ())
setFrameShadow arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFrame arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setFrameShadow' arg'1' arg'2')

setFrameShape :: (QFramePtr this) => (this) {- ^ this -} -> (QFrameShape) -> (HoppyP.IO ())
setFrameShape arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQFrame arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setFrameShape' arg'1' arg'2')

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

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

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

data QFrameConst =
    QFrameConst (HoppyF.Ptr QFrameConst)
  | QFrameConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFrameConst)
  deriving (HoppyP.Show)

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

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

castQFrameToConst :: QFrame -> QFrameConst
castQFrameToConst (QFrame ptr') = QFrameConst $ HoppyF.castPtr ptr'
castQFrameToConst (QFrameGc fptr' ptr') = QFrameConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFrameConstPtr QFrameConst where
  toQFrameConst = HoppyP.id

instance M506.QWidgetConstPtr QFrameConst where
  toQWidgetConst (QFrameConst ptr') = M506.QWidgetConst $ castQFrameToQWidget ptr'
  toQWidgetConst (QFrameConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQFrameToQWidget ptr'

instance M94.QObjectConstPtr QFrameConst where
  toQObjectConst (QFrameConst ptr') = M94.QObjectConst $ castQFrameToQObject ptr'
  toQObjectConst (QFrameConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFrameToQObject ptr'

data QFrame =
    QFrame (HoppyF.Ptr QFrame)
  | QFrameGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QFrame)
  deriving (HoppyP.Show)

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

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

castQFrameToNonconst :: QFrameConst -> QFrame
castQFrameToNonconst (QFrameConst ptr') = QFrame $ HoppyF.castPtr ptr'
castQFrameToNonconst (QFrameConstGc fptr' ptr') = QFrameGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QFrameConstPtr QFrame where
  toQFrameConst (QFrame ptr') = QFrameConst $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'
  toQFrameConst (QFrameGc fptr' ptr') = QFrameConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'

instance QFramePtr QFrame where
  toQFrame = HoppyP.id

instance M506.QWidgetConstPtr QFrame where
  toQWidgetConst (QFrame ptr') = M506.QWidgetConst $ castQFrameToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'
  toQWidgetConst (QFrameGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQFrameToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'

instance M506.QWidgetPtr QFrame where
  toQWidget (QFrame ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQFrameToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'
  toQWidget (QFrameGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQFrameToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'

instance M94.QObjectConstPtr QFrame where
  toQObjectConst (QFrame ptr') = M94.QObjectConst $ castQFrameToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'
  toQObjectConst (QFrameGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQFrameToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'

instance M94.QObjectPtr QFrame where
  toQObject (QFrame ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFrameToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'
  toQObject (QFrameGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQFrameToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QFrame -> HoppyF.Ptr QFrameConst) ptr'

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

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

class QFrameSuper a where
  downToQFrame :: a -> QFrame

instance QFrameSuper M506.QWidget where
  downToQFrame = castQFrameToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QFrameConst $ castQWidgetToQFrame ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QFrameConstGc fptr' $ castQWidgetToQFrame ptr'
instance QFrameSuper M94.QObject where
  downToQFrame = castQFrameToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QFrameConst $ castQObjectToQFrame ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFrameConstGc fptr' $ castQObjectToQFrame ptr'

class QFrameSuperConst a where
  downToQFrameConst :: a -> QFrameConst

instance QFrameSuperConst M506.QWidgetConst where
  downToQFrameConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QFrameConst $ castQWidgetToQFrame ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QFrameConstGc fptr' $ castQWidgetToQFrame ptr'
instance QFrameSuperConst M94.QObjectConst where
  downToQFrameConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QFrameConst $ castQObjectToQFrame ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QFrameConstGc fptr' $ castQObjectToQFrame ptr'

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

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

data QFrameShadow =
  Plain
  | Raised
  | Sunken
  | UnknownQFrameShadow (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFrameShadow where
  fromCppEnum Plain = 16
  fromCppEnum Raised = 32
  fromCppEnum Sunken = 48
  fromCppEnum (UnknownQFrameShadow n) = n
  
  toCppEnum (16) = Plain
  toCppEnum (32) = Raised
  toCppEnum (48) = Sunken
  toCppEnum n = UnknownQFrameShadow n

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

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

data QFrameShape =
  NoFrame
  | Box
  | Panel
  | WinPanel
  | HLine
  | VLine
  | StyledPanel
  | UnknownQFrameShape (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFrameShape where
  fromCppEnum NoFrame = 0
  fromCppEnum Box = 1
  fromCppEnum Panel = 2
  fromCppEnum WinPanel = 3
  fromCppEnum HLine = 4
  fromCppEnum VLine = 5
  fromCppEnum StyledPanel = 6
  fromCppEnum (UnknownQFrameShape n) = n
  
  toCppEnum (0) = NoFrame
  toCppEnum (1) = Box
  toCppEnum (2) = Panel
  toCppEnum (3) = WinPanel
  toCppEnum (4) = HLine
  toCppEnum (5) = VLine
  toCppEnum (6) = StyledPanel
  toCppEnum n = UnknownQFrameShape n

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

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

data QFrameStyleMask =
  ShapeMask
  | ShadowMask
  | UnknownQFrameStyleMask (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QFrameStyleMask where
  fromCppEnum ShapeMask = 15
  fromCppEnum ShadowMask = 240
  fromCppEnum (UnknownQFrameStyleMask n) = n
  
  toCppEnum (15) = ShapeMask
  toCppEnum (240) = ShadowMask
  toCppEnum n = UnknownQFrameStyleMask n

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

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