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

module Graphics.UI.Qtah.Generated.Widgets.QSystemTrayIcon (
  castQSystemTrayIconToQObject,
  castQObjectToQSystemTrayIcon,
  QSystemTrayIconValue (..),
  QSystemTrayIconConstPtr (..),
  contextMenu,
  geometry,
  icon,
  toolTip,
  isVisible,
  QSystemTrayIconPtr (..),
  setContextMenu,
  hide,
  setIcon,
  show,
  showMessage,
  showMessageAll,
  setToolTip,
  setVisible,
  emitActivated,
  emitMessageClicked,
  isSystemTrayAvailable,
  supportsMessages,
  QSystemTrayIconConst (..),
  castQSystemTrayIconToConst,
  QSystemTrayIcon (..),
  castQSystemTrayIconToNonconst,
  new,
  newWithParent,
  newWithIcon,
  newWithIconAndParent,
  QSystemTrayIconSuper (..),
  QSystemTrayIconSuperConst (..),
  QSystemTrayIconActivationReason (..),
  QSystemTrayIconMessageIcon (..),
  ) 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 qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Widgets.QMenu as M448
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QSystemTrayIcon_new" new' ::  HoppyP.IO (HoppyF.Ptr QSystemTrayIcon)
foreign import ccall "genpop__QSystemTrayIcon_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QSystemTrayIcon)
foreign import ccall "genpop__QSystemTrayIcon_newWithIcon" newWithIcon' ::  HoppyF.Ptr M288.QIconConst -> HoppyP.IO (HoppyF.Ptr QSystemTrayIcon)
foreign import ccall "genpop__QSystemTrayIcon_newWithIconAndParent" newWithIconAndParent' ::  HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QSystemTrayIcon)
foreign import ccall "genpop__QSystemTrayIcon_contextMenu" contextMenu' ::  HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO (HoppyF.Ptr M448.QMenu)
foreign import ccall "genpop__QSystemTrayIcon_setContextMenu" setContextMenu' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr M448.QMenu -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_geometry" geometry' ::  HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO (HoppyF.Ptr M122.QRectConst)
foreign import ccall "genpop__QSystemTrayIcon_hide" hide' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_icon" icon' ::  HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO (HoppyF.Ptr M288.QIconConst)
foreign import ccall "genpop__QSystemTrayIcon_setIcon" setIcon' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_isSystemTrayAvailable" isSystemTrayAvailable' ::  HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSystemTrayIcon_show" show' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_showMessage" showMessage' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_showMessageAll" showMessageAll' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_supportsMessages" supportsMessages' ::  HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSystemTrayIcon_toolTip" toolTip' ::  HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QSystemTrayIcon_setToolTip" setToolTip' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_isVisible" isVisible' ::  HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QSystemTrayIcon_setVisible" setVisible' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_emitActivated" emitActivated' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QSystemTrayIcon_emitMessageClicked" emitMessageClicked' ::  HoppyF.Ptr QSystemTrayIcon -> HoppyP.IO ()
foreign import ccall "gencast__QSystemTrayIcon__QObject" castQSystemTrayIconToQObject :: HoppyF.Ptr QSystemTrayIconConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QSystemTrayIcon" castQObjectToQSystemTrayIcon :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QSystemTrayIconConst
foreign import ccall "gendel__QSystemTrayIcon" delete'QSystemTrayIcon :: HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO ()
foreign import ccall "&gendel__QSystemTrayIcon" deletePtr'QSystemTrayIcon :: HoppyF.FunPtr (HoppyF.Ptr QSystemTrayIconConst -> HoppyP.IO ())

class QSystemTrayIconValue a where
  withQSystemTrayIconPtr :: a -> (QSystemTrayIconConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QSystemTrayIconConstPtr a => QSystemTrayIconValue a where
  withQSystemTrayIconPtr = HoppyP.flip ($) . toQSystemTrayIconConst

class (M94.QObjectConstPtr this) => QSystemTrayIconConstPtr this where
  toQSystemTrayIconConst :: this -> QSystemTrayIconConst

contextMenu :: (QSystemTrayIconValue this) => (this) {- ^ this -} -> (HoppyP.IO M448.QMenu)
contextMenu arg'1 =
  withQSystemTrayIconPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M448.QMenu
  (contextMenu' arg'1')

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

icon :: (QSystemTrayIconValue this) => (this) {- ^ this -} -> (HoppyP.IO M288.QIcon)
icon arg'1 =
  withQSystemTrayIconPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M288.QIconConst) =<<
  (icon' arg'1')

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

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

class (QSystemTrayIconConstPtr this, M94.QObjectPtr this) => QSystemTrayIconPtr this where
  toQSystemTrayIcon :: this -> QSystemTrayIcon

setContextMenu :: (QSystemTrayIconPtr this, M448.QMenuPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setContextMenu arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M448.toQMenu arg'2) $ \arg'2' ->
  (setContextMenu' arg'1' arg'2')

hide :: (QSystemTrayIconPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
hide arg'1 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  (hide' arg'1')

setIcon :: (QSystemTrayIconPtr this, M288.QIconValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setIcon arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  M288.withQIconPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setIcon' arg'1' arg'2')

show :: (QSystemTrayIconPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
show arg'1 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  (show' arg'1')

showMessage :: (QSystemTrayIconPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO ())
showMessage arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (showMessage' arg'1' arg'2' arg'3')

showMessageAll :: (QSystemTrayIconPtr this, M142.QStringValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (QSystemTrayIconMessageIcon) -> (HoppyP.Int) -> (HoppyP.IO ())
showMessageAll arg'1 arg'2 arg'3 arg'4 arg'5 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'4 >>= \arg'4' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'5 >>= \arg'5' ->
  (showMessageAll' arg'1' arg'2' arg'3' arg'4' arg'5')

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

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

emitActivated :: (QSystemTrayIconPtr this) => (this) {- ^ this -} -> (QSystemTrayIconActivationReason) -> (HoppyP.IO ())
emitActivated arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitActivated' arg'1' arg'2')

emitMessageClicked :: (QSystemTrayIconPtr this) => (this) {- ^ this -} -> (HoppyP.IO ())
emitMessageClicked arg'1 =
  HoppyFHR.withCppPtr (toQSystemTrayIcon arg'1) $ \arg'1' ->
  (emitMessageClicked' arg'1')

isSystemTrayAvailable :: (HoppyP.IO HoppyP.Bool)
isSystemTrayAvailable =
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isSystemTrayAvailable')

supportsMessages :: (HoppyP.IO HoppyP.Bool)
supportsMessages =
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (supportsMessages')

data QSystemTrayIconConst =
    QSystemTrayIconConst (HoppyF.Ptr QSystemTrayIconConst)
  | QSystemTrayIconConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSystemTrayIconConst)
  deriving (HoppyP.Show)

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

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

castQSystemTrayIconToConst :: QSystemTrayIcon -> QSystemTrayIconConst
castQSystemTrayIconToConst (QSystemTrayIcon ptr') = QSystemTrayIconConst $ HoppyF.castPtr ptr'
castQSystemTrayIconToConst (QSystemTrayIconGc fptr' ptr') = QSystemTrayIconConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSystemTrayIconConstPtr QSystemTrayIconConst where
  toQSystemTrayIconConst = HoppyP.id

instance M94.QObjectConstPtr QSystemTrayIconConst where
  toQObjectConst (QSystemTrayIconConst ptr') = M94.QObjectConst $ castQSystemTrayIconToQObject ptr'
  toQObjectConst (QSystemTrayIconConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSystemTrayIconToQObject ptr'

data QSystemTrayIcon =
    QSystemTrayIcon (HoppyF.Ptr QSystemTrayIcon)
  | QSystemTrayIconGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QSystemTrayIcon)
  deriving (HoppyP.Show)

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

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

castQSystemTrayIconToNonconst :: QSystemTrayIconConst -> QSystemTrayIcon
castQSystemTrayIconToNonconst (QSystemTrayIconConst ptr') = QSystemTrayIcon $ HoppyF.castPtr ptr'
castQSystemTrayIconToNonconst (QSystemTrayIconConstGc fptr' ptr') = QSystemTrayIconGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QSystemTrayIconConstPtr QSystemTrayIcon where
  toQSystemTrayIconConst (QSystemTrayIcon ptr') = QSystemTrayIconConst $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'
  toQSystemTrayIconConst (QSystemTrayIconGc fptr' ptr') = QSystemTrayIconConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'

instance QSystemTrayIconPtr QSystemTrayIcon where
  toQSystemTrayIcon = HoppyP.id

instance M94.QObjectConstPtr QSystemTrayIcon where
  toQObjectConst (QSystemTrayIcon ptr') = M94.QObjectConst $ castQSystemTrayIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'
  toQObjectConst (QSystemTrayIconGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQSystemTrayIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'

instance M94.QObjectPtr QSystemTrayIcon where
  toQObject (QSystemTrayIcon ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSystemTrayIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'
  toQObject (QSystemTrayIconGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQSystemTrayIconToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QSystemTrayIcon -> HoppyF.Ptr QSystemTrayIconConst) ptr'

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

newWithParent :: (M94.QObjectPtr arg'1) => (arg'1) -> (HoppyP.IO QSystemTrayIcon)
newWithParent arg'1 =
  HoppyFHR.withCppPtr (M94.toQObject arg'1) $ \arg'1' ->
  HoppyP.fmap QSystemTrayIcon
  (newWithParent' arg'1')

newWithIcon :: (M288.QIconValue arg'1) => (arg'1) -> (HoppyP.IO QSystemTrayIcon)
newWithIcon arg'1 =
  M288.withQIconPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QSystemTrayIcon
  (newWithIcon' arg'1')

newWithIconAndParent :: (M288.QIconValue arg'1, M94.QObjectPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QSystemTrayIcon)
newWithIconAndParent arg'1 arg'2 =
  M288.withQIconPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'2) $ \arg'2' ->
  HoppyP.fmap QSystemTrayIcon
  (newWithIconAndParent' arg'1' arg'2')

class QSystemTrayIconSuper a where
  downToQSystemTrayIcon :: a -> QSystemTrayIcon

instance QSystemTrayIconSuper M94.QObject where
  downToQSystemTrayIcon = castQSystemTrayIconToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QSystemTrayIconConst $ castQObjectToQSystemTrayIcon ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSystemTrayIconConstGc fptr' $ castQObjectToQSystemTrayIcon ptr'

class QSystemTrayIconSuperConst a where
  downToQSystemTrayIconConst :: a -> QSystemTrayIconConst

instance QSystemTrayIconSuperConst M94.QObjectConst where
  downToQSystemTrayIconConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QSystemTrayIconConst $ castQObjectToQSystemTrayIcon ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QSystemTrayIconConstGc fptr' $ castQObjectToQSystemTrayIcon ptr'

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

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

data QSystemTrayIconActivationReason =
  Unknown
  | Context
  | DoubleClick
  | Trigger
  | MiddleClick
  | UnknownQSystemTrayIconActivationReason (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSystemTrayIconActivationReason where
  fromCppEnum Unknown = 0
  fromCppEnum Context = 1
  fromCppEnum DoubleClick = 2
  fromCppEnum Trigger = 3
  fromCppEnum MiddleClick = 4
  fromCppEnum (UnknownQSystemTrayIconActivationReason n) = n
  
  toCppEnum (0) = Unknown
  toCppEnum (1) = Context
  toCppEnum (2) = DoubleClick
  toCppEnum (3) = Trigger
  toCppEnum (4) = MiddleClick
  toCppEnum n = UnknownQSystemTrayIconActivationReason n

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

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

data QSystemTrayIconMessageIcon =
  NoIcon
  | Information
  | Warning
  | Critical
  | UnknownQSystemTrayIconMessageIcon (HoppyFC.CInt)
  deriving (HoppyP.Show)

instance HoppyFHR.CppEnum (HoppyFC.CInt) QSystemTrayIconMessageIcon where
  fromCppEnum NoIcon = 0
  fromCppEnum Information = 1
  fromCppEnum Warning = 2
  fromCppEnum Critical = 3
  fromCppEnum (UnknownQSystemTrayIconMessageIcon n) = n
  
  toCppEnum (0) = NoIcon
  toCppEnum (1) = Information
  toCppEnum (2) = Warning
  toCppEnum (3) = Critical
  toCppEnum n = UnknownQSystemTrayIconMessageIcon n

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

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