QOpenGLWidget.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QOpenGLWidget (
  castQOpenGLWidgetToQWidget,
  castQWidgetToQOpenGLWidget,
  castQOpenGLWidgetToQObject,
  castQObjectToQOpenGLWidget,
  QOpenGLWidgetValue (..),
  QOpenGLWidgetConstPtr (..),
  defaultFramebufferObject,
  isValid,
  updateBehavior,
  QOpenGLWidgetPtr (..),
  doneCurrent,
  grabFramebuffer,
  makeCurrent,
  setUpdateBehavior,
  emitAboutToCompose,
  emitAboutToResize,
  emitFrameSwapped,
  emitResized,
  QOpenGLWidgetConst (..),
  castQOpenGLWidgetToConst,
  QOpenGLWidget (..),
  castQOpenGLWidgetToNonconst,
  new,
  newWithParent,
  newWithParentAndFlags,
  QOpenGLWidgetSuper (..),
  QOpenGLWidgetSuperConst (..),
  QOpenGLWidgetUpdateBehavior (..),
  ) where

import qualified Data.Word as HoppyDW
import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
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.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QImage as M292
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__QOpenGLWidget_new" new' ::  HoppyP.IO (HoppyF.Ptr QOpenGLWidget)
foreign import ccall "genpop__QOpenGLWidget_newWithParent" newWithParent' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO (HoppyF.Ptr QOpenGLWidget)
foreign import ccall "genpop__QOpenGLWidget_newWithParentAndFlags" newWithParentAndFlags' ::  HoppyF.Ptr QOpenGLWidget -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QOpenGLWidget)
foreign import ccall "genpop__QOpenGLWidget_defaultFramebufferObject" defaultFramebufferObject' ::  HoppyF.Ptr QOpenGLWidgetConst -> HoppyP.IO HoppyDW.Word32
foreign import ccall "genpop__QOpenGLWidget_doneCurrent" doneCurrent' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_grabFramebuffer" grabFramebuffer' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO (HoppyF.Ptr M292.QImageConst)
foreign import ccall "genpop__QOpenGLWidget_isValid" isValid' ::  HoppyF.Ptr QOpenGLWidgetConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QOpenGLWidget_makeCurrent" makeCurrent' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_updateBehavior" updateBehavior' ::  HoppyF.Ptr QOpenGLWidgetConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QOpenGLWidget_setUpdateBehavior" setUpdateBehavior' ::  HoppyF.Ptr QOpenGLWidget -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_emitAboutToCompose" emitAboutToCompose' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_emitAboutToResize" emitAboutToResize' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_emitFrameSwapped" emitFrameSwapped' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "genpop__QOpenGLWidget_emitResized" emitResized' ::  HoppyF.Ptr QOpenGLWidget -> HoppyP.IO ()
foreign import ccall "gencast__QOpenGLWidget__QWidget" castQOpenGLWidgetToQWidget :: HoppyF.Ptr QOpenGLWidgetConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QOpenGLWidget" castQWidgetToQOpenGLWidget :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QOpenGLWidgetConst
foreign import ccall "gencast__QOpenGLWidget__QObject" castQOpenGLWidgetToQObject :: HoppyF.Ptr QOpenGLWidgetConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QOpenGLWidget" castQObjectToQOpenGLWidget :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QOpenGLWidgetConst
foreign import ccall "gendel__QOpenGLWidget" delete'QOpenGLWidget :: HoppyF.Ptr QOpenGLWidgetConst -> HoppyP.IO ()
foreign import ccall "&gendel__QOpenGLWidget" deletePtr'QOpenGLWidget :: HoppyF.FunPtr (HoppyF.Ptr QOpenGLWidgetConst -> HoppyP.IO ())

class QOpenGLWidgetValue a where
  withQOpenGLWidgetPtr :: a -> (QOpenGLWidgetConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QOpenGLWidgetConstPtr a => QOpenGLWidgetValue a where
  withQOpenGLWidgetPtr = HoppyP.flip ($) . toQOpenGLWidgetConst

class (M506.QWidgetConstPtr this) => QOpenGLWidgetConstPtr this where
  toQOpenGLWidgetConst :: this -> QOpenGLWidgetConst

defaultFramebufferObject :: (QOpenGLWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO HoppyDW.Word32)
defaultFramebufferObject arg'1 =
  withQOpenGLWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (defaultFramebufferObject' arg'1')

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

updateBehavior :: (QOpenGLWidgetValue this) => (this) {- ^ this -} -> (HoppyP.IO QOpenGLWidgetUpdateBehavior)
updateBehavior arg'1 =
  withQOpenGLWidgetPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (updateBehavior' arg'1')

class (QOpenGLWidgetConstPtr this, M506.QWidgetPtr this) => QOpenGLWidgetPtr this where
  toQOpenGLWidget :: this -> QOpenGLWidget

doneCurrent :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
doneCurrent arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (doneCurrent' arg'1')

grabFramebuffer :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO M292.QImage)
grabFramebuffer arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M292.QImageConst) =<<
  (grabFramebuffer' arg'1')

makeCurrent :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
makeCurrent arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (makeCurrent' arg'1')

setUpdateBehavior :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (QOpenGLWidgetUpdateBehavior) -> (HoppyP.IO ())
setUpdateBehavior arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setUpdateBehavior' arg'1' arg'2')

emitAboutToCompose :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitAboutToCompose arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (emitAboutToCompose' arg'1')

emitAboutToResize :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitAboutToResize arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (emitAboutToResize' arg'1')

emitFrameSwapped :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitFrameSwapped arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (emitFrameSwapped' arg'1')

emitResized :: (QOpenGLWidgetPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitResized arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (emitResized' arg'1')

data QOpenGLWidgetConst =
    QOpenGLWidgetConst (HoppyF.Ptr QOpenGLWidgetConst)
  | QOpenGLWidgetConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QOpenGLWidgetConst)
  deriving (HoppyP.Show)

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

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

castQOpenGLWidgetToConst :: QOpenGLWidget -> QOpenGLWidgetConst
castQOpenGLWidgetToConst (QOpenGLWidget ptr') = QOpenGLWidgetConst $ HoppyF.castPtr ptr'
castQOpenGLWidgetToConst (QOpenGLWidgetGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QOpenGLWidgetConstPtr QOpenGLWidgetConst where
  toQOpenGLWidgetConst = HoppyP.id

instance M506.QWidgetConstPtr QOpenGLWidgetConst where
  toQWidgetConst (QOpenGLWidgetConst ptr') = M506.QWidgetConst $ castQOpenGLWidgetToQWidget ptr'
  toQWidgetConst (QOpenGLWidgetConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQOpenGLWidgetToQWidget ptr'

instance M94.QObjectConstPtr QOpenGLWidgetConst where
  toQObjectConst (QOpenGLWidgetConst ptr') = M94.QObjectConst $ castQOpenGLWidgetToQObject ptr'
  toQObjectConst (QOpenGLWidgetConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQOpenGLWidgetToQObject ptr'

data QOpenGLWidget =
    QOpenGLWidget (HoppyF.Ptr QOpenGLWidget)
  | QOpenGLWidgetGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QOpenGLWidget)
  deriving (HoppyP.Show)

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

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

castQOpenGLWidgetToNonconst :: QOpenGLWidgetConst -> QOpenGLWidget
castQOpenGLWidgetToNonconst (QOpenGLWidgetConst ptr') = QOpenGLWidget $ HoppyF.castPtr ptr'
castQOpenGLWidgetToNonconst (QOpenGLWidgetConstGc fptr' ptr') = QOpenGLWidgetGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QOpenGLWidgetConstPtr QOpenGLWidget where
  toQOpenGLWidgetConst (QOpenGLWidget ptr') = QOpenGLWidgetConst $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'
  toQOpenGLWidgetConst (QOpenGLWidgetGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'

instance QOpenGLWidgetPtr QOpenGLWidget where
  toQOpenGLWidget = HoppyP.id

instance M506.QWidgetConstPtr QOpenGLWidget where
  toQWidgetConst (QOpenGLWidget ptr') = M506.QWidgetConst $ castQOpenGLWidgetToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'
  toQWidgetConst (QOpenGLWidgetGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQOpenGLWidgetToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'

instance M506.QWidgetPtr QOpenGLWidget where
  toQWidget (QOpenGLWidget ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQOpenGLWidgetToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'
  toQWidget (QOpenGLWidgetGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQOpenGLWidgetToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'

instance M94.QObjectConstPtr QOpenGLWidget where
  toQObjectConst (QOpenGLWidget ptr') = M94.QObjectConst $ castQOpenGLWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'
  toQObjectConst (QOpenGLWidgetGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQOpenGLWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'

instance M94.QObjectPtr QOpenGLWidget where
  toQObject (QOpenGLWidget ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQOpenGLWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'
  toQObject (QOpenGLWidgetGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQOpenGLWidgetToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QOpenGLWidget -> HoppyF.Ptr QOpenGLWidgetConst) ptr'

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

newWithParent :: (QOpenGLWidgetPtr arg'1) => (arg'1) -> (HoppyP.IO QOpenGLWidget)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  HoppyP.fmap QOpenGLWidget
  (newWithParent' arg'1')

newWithParentAndFlags :: (QOpenGLWidgetPtr arg'1, M190.IsQtWindowFlags arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QOpenGLWidget)
newWithParentAndFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQOpenGLWidget arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtWindowFlags
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QOpenGLWidget
  (newWithParentAndFlags' arg'1' arg'2')

class QOpenGLWidgetSuper a where
  downToQOpenGLWidget :: a -> QOpenGLWidget

instance QOpenGLWidgetSuper M506.QWidget where
  downToQOpenGLWidget = castQOpenGLWidgetToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QOpenGLWidgetConst $ castQWidgetToQOpenGLWidget ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ castQWidgetToQOpenGLWidget ptr'
instance QOpenGLWidgetSuper M94.QObject where
  downToQOpenGLWidget = castQOpenGLWidgetToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QOpenGLWidgetConst $ castQObjectToQOpenGLWidget ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ castQObjectToQOpenGLWidget ptr'

class QOpenGLWidgetSuperConst a where
  downToQOpenGLWidgetConst :: a -> QOpenGLWidgetConst

instance QOpenGLWidgetSuperConst M506.QWidgetConst where
  downToQOpenGLWidgetConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QOpenGLWidgetConst $ castQWidgetToQOpenGLWidget ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ castQWidgetToQOpenGLWidget ptr'
instance QOpenGLWidgetSuperConst M94.QObjectConst where
  downToQOpenGLWidgetConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QOpenGLWidgetConst $ castQObjectToQOpenGLWidget ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QOpenGLWidgetConstGc fptr' $ castQObjectToQOpenGLWidget ptr'

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

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

data QOpenGLWidgetUpdateBehavior =
  NoPartialUpdate
  | PartialUpdate
  | UnknownQOpenGlWidgetUpdateBehavior (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QOpenGLWidgetUpdateBehavior where
  fromCppEnum NoPartialUpdate = 0
  fromCppEnum PartialUpdate = 1
  fromCppEnum (UnknownQOpenGlWidgetUpdateBehavior n) = n
  
  toCppEnum (0) = NoPartialUpdate
  toCppEnum (1) = PartialUpdate
  toCppEnum n = UnknownQOpenGlWidgetUpdateBehavior n

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

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