QClipboard.hs

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

module Graphics.UI.Qtah.Generated.Gui.QClipboard (
  castQClipboardToQObject,
  castQObjectToQClipboard,
  QClipboardValue (..),
  QClipboardConstPtr (..),
  image,
  imageAll,
  ownsClipboard,
  ownsFindBuffer,
  ownsSelection,
  pixmap,
  pixmapAll,
  supportsFindBuffer,
  supportsSelection,
  text,
  textWithMode,
  textSubtype,
  textSubtypeWithMode,
  QClipboardPtr (..),
  clear,
  clearWithMode,
  setImage,
  setImageAll,
  setPixmap,
  setPixmapAll,
  setText,
  setTextWithMode,
  emitChanged,
  emitDataChanged,
  emitFindBufferChanged,
  emitSelectionChanged,
  QClipboardConst (..),
  castQClipboardToConst,
  QClipboard (..),
  castQClipboardToNonconst,
  QClipboardSuper (..),
  QClipboardSuperConst (..),
  QClipboardMode (..),
  ) 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 {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QImage as M292
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QPixmap as M316
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QClipboard_clear" clear' ::  HoppyF.Ptr QClipboard -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_clearWithMode" clearWithMode' ::  HoppyF.Ptr QClipboard -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_image" image' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO (HoppyF.Ptr M292.QImageConst)
foreign import ccall "genpop__QClipboard_imageAll" imageAll' ::  HoppyF.Ptr QClipboardConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M292.QImageConst)
foreign import ccall "genpop__QClipboard_ownsClipboard" ownsClipboard' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QClipboard_ownsFindBuffer" ownsFindBuffer' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QClipboard_ownsSelection" ownsSelection' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QClipboard_pixmap" pixmap' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO (HoppyF.Ptr M316.QPixmapConst)
foreign import ccall "genpop__QClipboard_pixmapAll" pixmapAll' ::  HoppyF.Ptr QClipboardConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M316.QPixmapConst)
foreign import ccall "genpop__QClipboard_setImage" setImage' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M292.QImageConst -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_setImageAll" setImageAll' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M292.QImageConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_setPixmap" setPixmap' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M316.QPixmapConst -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_setPixmapAll" setPixmapAll' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M316.QPixmapConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_setText" setText' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_setTextWithMode" setTextWithMode' ::  HoppyF.Ptr QClipboard -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_supportsFindBuffer" supportsFindBuffer' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QClipboard_supportsSelection" supportsSelection' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QClipboard_text" text' ::  HoppyF.Ptr QClipboardConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QClipboard_textWithMode" textWithMode' ::  HoppyF.Ptr QClipboardConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QClipboard_textSubtype" textSubtype' ::  HoppyF.Ptr QClipboardConst -> HoppyF.Ptr M142.QString -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QClipboard_textSubtypeWithMode" textSubtypeWithMode' ::  HoppyF.Ptr QClipboardConst -> HoppyF.Ptr M142.QString -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QClipboard_emitChanged" emitChanged' ::  HoppyF.Ptr QClipboard -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_emitDataChanged" emitDataChanged' ::  HoppyF.Ptr QClipboard -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_emitFindBufferChanged" emitFindBufferChanged' ::  HoppyF.Ptr QClipboard -> HoppyP.IO ()
foreign import ccall "genpop__QClipboard_emitSelectionChanged" emitSelectionChanged' ::  HoppyF.Ptr QClipboard -> HoppyP.IO ()
foreign import ccall "gencast__QClipboard__QObject" castQClipboardToQObject :: HoppyF.Ptr QClipboardConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QClipboard" castQObjectToQClipboard :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QClipboardConst

class QClipboardValue a where
  withQClipboardPtr :: a -> (QClipboardConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QClipboardConstPtr a => QClipboardValue a where
  withQClipboardPtr = HoppyP.flip ($) . toQClipboardConst

class (M94.QObjectConstPtr this) => QClipboardConstPtr this where
  toQClipboardConst :: this -> QClipboardConst

image :: (QClipboardValue this) => (this) {- ^ this -} -> (HoppyP.IO M292.QImage)
image arg'1 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M292.QImageConst) =<<
  (image' arg'1')

imageAll :: (QClipboardValue this) => (this) {- ^ this -} -> (QClipboardMode) -> (HoppyP.IO M292.QImage)
imageAll arg'1 arg'2 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M292.QImageConst) =<<
  (imageAll' arg'1' arg'2')

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

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

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

pixmap :: (QClipboardValue this) => (this) {- ^ this -} -> (HoppyP.IO M316.QPixmap)
pixmap arg'1 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M316.QPixmapConst) =<<
  (pixmap' arg'1')

pixmapAll :: (QClipboardValue this) => (this) {- ^ this -} -> (QClipboardMode) -> (HoppyP.IO M316.QPixmap)
pixmapAll arg'1 arg'2 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M316.QPixmapConst) =<<
  (pixmapAll' arg'1' arg'2')

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

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

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

textWithMode :: (QClipboardValue this) => (this) {- ^ this -} -> (QClipboardMode) -> (HoppyP.IO QtahP.String)
textWithMode arg'1 arg'2 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (textWithMode' arg'1' arg'2')

textSubtype :: (QClipboardValue this, M142.QStringPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO QtahP.String)
textSubtype arg'1 arg'2 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M142.toQString arg'2) $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (textSubtype' arg'1' arg'2')

textSubtypeWithMode :: (QClipboardValue this, M142.QStringPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (QClipboardMode) -> (HoppyP.IO QtahP.String)
textSubtypeWithMode arg'1 arg'2 arg'3 =
  withQClipboardPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M142.toQString arg'2) $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M142.QStringConst) =<<
  (textSubtypeWithMode' arg'1' arg'2' arg'3')

class (QClipboardConstPtr this, M94.QObjectPtr this) => QClipboardPtr this where
  toQClipboard :: this -> QClipboard

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

clearWithMode :: (QClipboardPtr this) => (this) {- ^ this -} -> (QClipboardMode) -> (HoppyP.IO ())
clearWithMode arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (clearWithMode' arg'1' arg'2')

setImage :: (QClipboardPtr this, M292.QImageValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setImage arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  M292.withQImagePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setImage' arg'1' arg'2')

setImageAll :: (QClipboardPtr this, M292.QImageValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QClipboardMode) -> (HoppyP.IO ())
setImageAll arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  M292.withQImagePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (setImageAll' arg'1' arg'2' arg'3')

setPixmap :: (QClipboardPtr this, M316.QPixmapValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setPixmap arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  M316.withQPixmapPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setPixmap' arg'1' arg'2')

setPixmapAll :: (QClipboardPtr this, M316.QPixmapValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QClipboardMode) -> (HoppyP.IO ())
setPixmapAll arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  M316.withQPixmapPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (setPixmapAll' arg'1' arg'2' arg'3')

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

setTextWithMode :: (QClipboardPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (QClipboardMode) -> (HoppyP.IO ())
setTextWithMode arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (setTextWithMode' arg'1' arg'2' arg'3')

emitChanged :: (QClipboardPtr this) => (this) {- ^ this -} -> (QClipboardMode) -> (HoppyP.IO ())
emitChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitChanged' arg'1' arg'2')

emitDataChanged :: (QClipboardPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitDataChanged arg'1 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  (emitDataChanged' arg'1')

emitFindBufferChanged :: (QClipboardPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitFindBufferChanged arg'1 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  (emitFindBufferChanged' arg'1')

emitSelectionChanged :: (QClipboardPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitSelectionChanged arg'1 =
  HoppyFHR.withCppPtr (toQClipboard arg'1) $ \arg'1' ->
  (emitSelectionChanged' arg'1')

data QClipboardConst =
    QClipboardConst (HoppyF.Ptr QClipboardConst)
  | QClipboardConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QClipboardConst)
  deriving (HoppyP.Show)

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

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

castQClipboardToConst :: QClipboard -> QClipboardConst
castQClipboardToConst (QClipboard ptr') = QClipboardConst $ HoppyF.castPtr ptr'
castQClipboardToConst (QClipboardGc fptr' ptr') = QClipboardConstGc fptr' $ HoppyF.castPtr ptr'

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

instance QClipboardConstPtr QClipboardConst where
  toQClipboardConst = HoppyP.id

instance M94.QObjectConstPtr QClipboardConst where
  toQObjectConst (QClipboardConst ptr') = M94.QObjectConst $ castQClipboardToQObject ptr'
  toQObjectConst (QClipboardConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQClipboardToQObject ptr'

data QClipboard =
    QClipboard (HoppyF.Ptr QClipboard)
  | QClipboardGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QClipboard)
  deriving (HoppyP.Show)

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

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

castQClipboardToNonconst :: QClipboardConst -> QClipboard
castQClipboardToNonconst (QClipboardConst ptr') = QClipboard $ HoppyF.castPtr ptr'
castQClipboardToNonconst (QClipboardConstGc fptr' ptr') = QClipboardGc fptr' $ HoppyF.castPtr ptr'

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

instance QClipboardConstPtr QClipboard where
  toQClipboardConst (QClipboard ptr') = QClipboardConst $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'
  toQClipboardConst (QClipboardGc fptr' ptr') = QClipboardConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'

instance QClipboardPtr QClipboard where
  toQClipboard = HoppyP.id

instance M94.QObjectConstPtr QClipboard where
  toQObjectConst (QClipboard ptr') = M94.QObjectConst $ castQClipboardToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'
  toQObjectConst (QClipboardGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQClipboardToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'

instance M94.QObjectPtr QClipboard where
  toQObject (QClipboard ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQClipboardToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'
  toQObject (QClipboardGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQClipboardToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QClipboard -> HoppyF.Ptr QClipboardConst) ptr'

class QClipboardSuper a where
  downToQClipboard :: a -> QClipboard

instance QClipboardSuper M94.QObject where
  downToQClipboard = castQClipboardToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QClipboardConst $ castQObjectToQClipboard ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QClipboardConstGc fptr' $ castQObjectToQClipboard ptr'

class QClipboardSuperConst a where
  downToQClipboardConst :: a -> QClipboardConst

instance QClipboardSuperConst M94.QObjectConst where
  downToQClipboardConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QClipboardConst $ castQObjectToQClipboard ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QClipboardConstGc fptr' $ castQObjectToQClipboard ptr'

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

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

data QClipboardMode =
  Clipboard
  | Selection
  | FindBuffer
  | UnknownQClipboardMode (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QClipboardMode where
  fromCppEnum Clipboard = 0
  fromCppEnum Selection = 1
  fromCppEnum FindBuffer = 2
  fromCppEnum (UnknownQClipboardMode n) = n
  
  toCppEnum (0) = Clipboard
  toCppEnum (1) = Selection
  toCppEnum (2) = FindBuffer
  toCppEnum n = UnknownQClipboardMode n

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

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