QToolBar.hs

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

module Graphics.UI.Qtah.Generated.Widgets.QToolBar (
  castQToolBarToQWidget,
  castQWidgetToQToolBar,
  castQToolBarToQObject,
  castQObjectToQToolBar,
  QToolBarValue (..),
  QToolBarConstPtr (..),
  allowedAreas,
  isFloatable,
  iconSize,
  isAreaAllowed,
  isFloating,
  isMovable,
  orientation,
  toolButtonStyle,
  widgetForAction,
  QToolBarPtr (..),
  addAction,
  addActionWithIcon,
  addSeparator,
  addWidget,
  setAllowedAreas,
  clear,
  setFloatable,
  setIconSize,
  insertSeparator,
  insertWidget,
  setMovable,
  setOrientation,
  toggleViewAction,
  setToolButtonStyle,
  emitActionTriggered,
  emitAllowedAreasChanged,
  emitIconSizeChanged,
  emitMovableChanged,
  emitOrientationChanged,
  emitToolButtonStyleChanged,
  emitTopLevelChanged,
  emitVisibilityChanged,
  QToolBarConst (..),
  castQToolBarToConst,
  QToolBar (..),
  castQToolBarToNonconst,
  new,
  newWithParent,
  newWithTitle,
  newWithTitleAndParent,
  QToolBarSuper (..),
  QToolBarSuperConst (..),
  ) 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.HSize as HSize
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.QSize as M134
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import qualified Graphics.UI.Qtah.Generated.Widgets.QAction as M368
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__QToolBar_new" new' ::  HoppyP.IO (HoppyF.Ptr QToolBar)
foreign import ccall "genpop__QToolBar_newWithParent" newWithParent' ::  HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QToolBar)
foreign import ccall "genpop__QToolBar_newWithTitle" newWithTitle' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QToolBar)
foreign import ccall "genpop__QToolBar_newWithTitleAndParent" newWithTitleAndParent' ::  HoppyF.Ptr M142.QStringConst -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr QToolBar)
foreign import ccall "genpop__QToolBar_addAction" addAction' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_addActionWithIcon" addActionWithIcon' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_addSeparator" addSeparator' ::  HoppyF.Ptr QToolBar -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_addWidget" addWidget' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_allowedAreas" allowedAreas' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBar_setAllowedAreas" setAllowedAreas' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_clear" clear' ::  HoppyF.Ptr QToolBar -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_isFloatable" isFloatable' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QToolBar_setFloatable" setFloatable' ::  HoppyF.Ptr QToolBar -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_iconSize" iconSize' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QToolBar_setIconSize" setIconSize' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_insertSeparator" insertSeparator' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M368.QAction -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_insertWidget" insertWidget' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M368.QAction -> HoppyF.Ptr M506.QWidget -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_isAreaAllowed" isAreaAllowed' ::  HoppyF.Ptr QToolBarConst -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QToolBar_isFloating" isFloating' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QToolBar_isMovable" isMovable' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QToolBar_setMovable" setMovable' ::  HoppyF.Ptr QToolBar -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_orientation" orientation' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBar_setOrientation" setOrientation' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_toggleViewAction" toggleViewAction' ::  HoppyF.Ptr QToolBar -> HoppyP.IO (HoppyF.Ptr M368.QAction)
foreign import ccall "genpop__QToolBar_toolButtonStyle" toolButtonStyle' ::  HoppyF.Ptr QToolBarConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QToolBar_setToolButtonStyle" setToolButtonStyle' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_widgetForAction" widgetForAction' ::  HoppyF.Ptr QToolBarConst -> HoppyF.Ptr M368.QAction -> HoppyP.IO (HoppyF.Ptr M506.QWidget)
foreign import ccall "genpop__QToolBar_emitActionTriggered" emitActionTriggered' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M368.QAction -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitAllowedAreasChanged" emitAllowedAreasChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitIconSizeChanged" emitIconSizeChanged' ::  HoppyF.Ptr QToolBar -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitMovableChanged" emitMovableChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitOrientationChanged" emitOrientationChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitToolButtonStyleChanged" emitToolButtonStyleChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitTopLevelChanged" emitTopLevelChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QToolBar_emitVisibilityChanged" emitVisibilityChanged' ::  HoppyF.Ptr QToolBar -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "gencast__QToolBar__QWidget" castQToolBarToQWidget :: HoppyF.Ptr QToolBarConst -> HoppyF.Ptr M506.QWidgetConst
foreign import ccall "gencast__QWidget__QToolBar" castQWidgetToQToolBar :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr QToolBarConst
foreign import ccall "gencast__QToolBar__QObject" castQToolBarToQObject :: HoppyF.Ptr QToolBarConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QToolBar" castQObjectToQToolBar :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QToolBarConst
foreign import ccall "gendel__QToolBar" delete'QToolBar :: HoppyF.Ptr QToolBarConst -> HoppyP.IO ()
foreign import ccall "&gendel__QToolBar" deletePtr'QToolBar :: HoppyF.FunPtr (HoppyF.Ptr QToolBarConst -> HoppyP.IO ())

class QToolBarValue a where
  withQToolBarPtr :: a -> (QToolBarConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QToolBarConstPtr a => QToolBarValue a where
  withQToolBarPtr = HoppyP.flip ($) . toQToolBarConst

class (M506.QWidgetConstPtr this) => QToolBarConstPtr this where
  toQToolBarConst :: this -> QToolBarConst

allowedAreas :: (QToolBarValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtToolBarAreas)
allowedAreas arg'1 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (allowedAreas' arg'1')

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

iconSize :: (QToolBarValue this) => (this) {- ^ this -} -> (HoppyP.IO HSize.HSize)
iconSize arg'1 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M134.QSizeConst) =<<
  (iconSize' arg'1')

isAreaAllowed :: (QToolBarValue this) => (this) {- ^ this -} -> (M190.QtToolBarArea) -> (HoppyP.IO HoppyP.Bool)
isAreaAllowed arg'1 arg'2 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (isAreaAllowed' arg'1' arg'2')

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

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

orientation :: (QToolBarValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtOrientation)
orientation arg'1 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (orientation' arg'1')

toolButtonStyle :: (QToolBarValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtToolButtonStyle)
toolButtonStyle arg'1 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (toolButtonStyle' arg'1')

widgetForAction :: (QToolBarValue this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M506.QWidget)
widgetForAction arg'1 arg'2 =
  withQToolBarPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  HoppyP.fmap M506.QWidget
  (widgetForAction' arg'1' arg'2')

class (QToolBarConstPtr this, M506.QWidgetPtr this) => QToolBarPtr this where
  toQToolBar :: this -> QToolBar

addAction :: (QToolBarPtr this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M368.QAction)
addAction arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M368.QAction
  (addAction' arg'1' arg'2')

addActionWithIcon :: (QToolBarPtr this, M288.QIconValue arg'2, M142.QStringValue arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO M368.QAction)
addActionWithIcon arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  M288.withQIconPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  M142.withQStringPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  HoppyP.fmap M368.QAction
  (addActionWithIcon' arg'1' arg'2' arg'3')

addSeparator :: (QToolBarPtr this) => (this) {- ^ this -} -> (HoppyP.IO M368.QAction)
addSeparator arg'1 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyP.fmap M368.QAction
  (addSeparator' arg'1')

addWidget :: (QToolBarPtr this, M506.QWidgetPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M368.QAction)
addWidget arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap M368.QAction
  (addWidget' arg'1' arg'2')

setAllowedAreas :: (QToolBarPtr this, M190.IsQtToolBarAreas arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setAllowedAreas arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtToolBarAreas
  ) arg'2 >>= \arg'2' ->
  (setAllowedAreas' arg'1' arg'2')

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

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

setIconSize :: (QToolBarPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setIconSize arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setIconSize' arg'1' arg'2')

insertSeparator :: (QToolBarPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M368.QAction)
insertSeparator arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  HoppyP.fmap M368.QAction
  (insertSeparator' arg'1' arg'2')

insertWidget :: (QToolBarPtr this, M368.QActionPtr arg'2, M506.QWidgetPtr arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO M368.QAction)
insertWidget arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'3) $ \arg'3' ->
  HoppyP.fmap M368.QAction
  (insertWidget' arg'1' arg'2' arg'3')

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

setOrientation :: (QToolBarPtr this) => (this) {- ^ this -} -> (M190.QtOrientation) -> (HoppyP.IO ())
setOrientation arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setOrientation' arg'1' arg'2')

toggleViewAction :: (QToolBarPtr this) => (this) {- ^ this -} -> (HoppyP.IO M368.QAction)
toggleViewAction arg'1 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyP.fmap M368.QAction
  (toggleViewAction' arg'1')

setToolButtonStyle :: (QToolBarPtr this) => (this) {- ^ this -} -> (M190.QtToolButtonStyle) -> (HoppyP.IO ())
setToolButtonStyle arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setToolButtonStyle' arg'1' arg'2')

emitActionTriggered :: (QToolBarPtr this, M368.QActionPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitActionTriggered arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (M368.toQAction arg'2) $ \arg'2' ->
  (emitActionTriggered' arg'1' arg'2')

emitAllowedAreasChanged :: (QToolBarPtr this, M190.IsQtToolBarAreas arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitAllowedAreasChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtToolBarAreas
  ) arg'2 >>= \arg'2' ->
  (emitAllowedAreasChanged' arg'1' arg'2')

emitIconSizeChanged :: (QToolBarPtr this, M134.QSizeValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
emitIconSizeChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  M134.withQSizePtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (emitIconSizeChanged' arg'1' arg'2')

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

emitOrientationChanged :: (QToolBarPtr this) => (this) {- ^ this -} -> (M190.QtOrientation) -> (HoppyP.IO ())
emitOrientationChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitOrientationChanged' arg'1' arg'2')

emitToolButtonStyleChanged :: (QToolBarPtr this) => (this) {- ^ this -} -> (M190.QtToolButtonStyle) -> (HoppyP.IO ())
emitToolButtonStyleChanged arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQToolBar arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (emitToolButtonStyleChanged' arg'1' arg'2')

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

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

data QToolBarConst =
    QToolBarConst (HoppyF.Ptr QToolBarConst)
  | QToolBarConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QToolBarConst)
  deriving (HoppyP.Show)

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

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

castQToolBarToConst :: QToolBar -> QToolBarConst
castQToolBarToConst (QToolBar ptr') = QToolBarConst $ HoppyF.castPtr ptr'
castQToolBarToConst (QToolBarGc fptr' ptr') = QToolBarConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QToolBarConstPtr QToolBarConst where
  toQToolBarConst = HoppyP.id

instance M506.QWidgetConstPtr QToolBarConst where
  toQWidgetConst (QToolBarConst ptr') = M506.QWidgetConst $ castQToolBarToQWidget ptr'
  toQWidgetConst (QToolBarConstGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQToolBarToQWidget ptr'

instance M94.QObjectConstPtr QToolBarConst where
  toQObjectConst (QToolBarConst ptr') = M94.QObjectConst $ castQToolBarToQObject ptr'
  toQObjectConst (QToolBarConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQToolBarToQObject ptr'

data QToolBar =
    QToolBar (HoppyF.Ptr QToolBar)
  | QToolBarGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QToolBar)
  deriving (HoppyP.Show)

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

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

castQToolBarToNonconst :: QToolBarConst -> QToolBar
castQToolBarToNonconst (QToolBarConst ptr') = QToolBar $ HoppyF.castPtr ptr'
castQToolBarToNonconst (QToolBarConstGc fptr' ptr') = QToolBarGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QToolBarConstPtr QToolBar where
  toQToolBarConst (QToolBar ptr') = QToolBarConst $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'
  toQToolBarConst (QToolBarGc fptr' ptr') = QToolBarConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'

instance QToolBarPtr QToolBar where
  toQToolBar = HoppyP.id

instance M506.QWidgetConstPtr QToolBar where
  toQWidgetConst (QToolBar ptr') = M506.QWidgetConst $ castQToolBarToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'
  toQWidgetConst (QToolBarGc fptr' ptr') = M506.QWidgetConstGc fptr' $ castQToolBarToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'

instance M506.QWidgetPtr QToolBar where
  toQWidget (QToolBar ptr') = M506.QWidget $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQToolBarToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'
  toQWidget (QToolBarGc fptr' ptr') = M506.QWidgetGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M506.QWidgetConst -> HoppyF.Ptr M506.QWidget) $ castQToolBarToQWidget $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'

instance M94.QObjectConstPtr QToolBar where
  toQObjectConst (QToolBar ptr') = M94.QObjectConst $ castQToolBarToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'
  toQObjectConst (QToolBarGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQToolBarToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'

instance M94.QObjectPtr QToolBar where
  toQObject (QToolBar ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQToolBarToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'
  toQObject (QToolBarGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQToolBarToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QToolBar -> HoppyF.Ptr QToolBarConst) ptr'

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

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

newWithTitle :: (M142.QStringValue arg'1) => (arg'1) -> (HoppyP.IO QToolBar)
newWithTitle arg'1 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QToolBar
  (newWithTitle' arg'1')

newWithTitleAndParent :: (M142.QStringValue arg'1, M506.QWidgetPtr arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QToolBar)
newWithTitleAndParent arg'1 arg'2 =
  M142.withQStringPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyFHR.withCppPtr (M506.toQWidget arg'2) $ \arg'2' ->
  HoppyP.fmap QToolBar
  (newWithTitleAndParent' arg'1' arg'2')

class QToolBarSuper a where
  downToQToolBar :: a -> QToolBar

instance QToolBarSuper M506.QWidget where
  downToQToolBar = castQToolBarToNonconst . cast' . M506.castQWidgetToConst
    where
      cast' (M506.QWidgetConst ptr') = QToolBarConst $ castQWidgetToQToolBar ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QToolBarConstGc fptr' $ castQWidgetToQToolBar ptr'
instance QToolBarSuper M94.QObject where
  downToQToolBar = castQToolBarToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QToolBarConst $ castQObjectToQToolBar ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QToolBarConstGc fptr' $ castQObjectToQToolBar ptr'

class QToolBarSuperConst a where
  downToQToolBarConst :: a -> QToolBarConst

instance QToolBarSuperConst M506.QWidgetConst where
  downToQToolBarConst = cast'
    where
      cast' (M506.QWidgetConst ptr') = QToolBarConst $ castQWidgetToQToolBar ptr'
      cast' (M506.QWidgetConstGc fptr' ptr') = QToolBarConstGc fptr' $ castQWidgetToQToolBar ptr'
instance QToolBarSuperConst M94.QObjectConst where
  downToQToolBarConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QToolBarConst $ castQObjectToQToolBar ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QToolBarConstGc fptr' $ castQObjectToQToolBar ptr'

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

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