QStandardItem.hs

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

module Graphics.UI.Qtah.Generated.Gui.QStandardItem (
  QStandardItemValue (..),
  QStandardItemConstPtr (..),
  accessibleDescription,
  accessibleText,
  background,
  checkState,
  child,
  childWithColumn,
  clone,
  column,
  columnCount,
  getData,
  getDataWithRole,
  flags,
  font,
  foreground,
  hasChildren,
  icon,
  index,
  isAutoTristate,
  isCheckable,
  isDragEnabled,
  isDropEnabled,
  isEditable,
  isEnabled,
  isSelectable,
  isUserTristate,
  model,
  parent,
  row,
  rowCount,
  sizeHint,
  statusTip,
  text,
  textAlignment,
  toolTip,
  getType,
  whatsThis,
  QStandardItemPtr (..),
  appendColumn,
  appendRowItems,
  appendRowItem,
  appendRows,
  insertColumn,
  insertColumns,
  insertRowItems,
  insertRowItem,
  insertRowsItems,
  insertRowsCount,
  removeColumn,
  removeColumns,
  removeRow,
  removeRows,
  setAccessibleDescription,
  setAccessibleText,
  setAutoTristate,
  setBackground,
  setCheckState,
  setCheckable,
  setChildWithColumn,
  setChild,
  setColumnCount,
  setData,
  setDataWithRole,
  setDragEnabled,
  setDropEnabled,
  setEditable,
  setEnabled,
  setFlags,
  setFont,
  setForeground,
  setIcon,
  setRowCount,
  setSelectable,
  setSizeHint,
  setStatusTip,
  setText,
  setTextAlignment,
  setToolTip,
  setUserTristate,
  setWhatsThis,
  sortChildren,
  sortChildrenWithOrder,
  takeChild,
  takeChildWithColumn,
  takeColumn,
  takeRow,
  QStandardItemConst (..),
  castQStandardItemToConst,
  QStandardItem (..),
  castQStandardItemToNonconst,
  new,
  newWithText,
  newWithIconAndText,
  newWithRows,
  newWithRowsAndColumns,
  QStandardItemSuper (..),
  QStandardItemSuperConst (..),
  ) 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 {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Core.QList.QStandardItem as M332
import qualified Graphics.UI.Qtah.Generated.Core.QModelIndex as M92
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.QVariant as M168
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import qualified Graphics.UI.Qtah.Generated.Gui.QBrush as M246
import qualified Graphics.UI.Qtah.Generated.Gui.QFont as M276
import qualified Graphics.UI.Qtah.Generated.Gui.QIcon as M288
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QStandardItemModel as M328
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QStandardItem_new" new' ::  HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_newWithText" newWithText' ::  HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_newWithIconAndText" newWithIconAndText' ::  HoppyF.Ptr M288.QIconConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_newWithRows" newWithRows' ::  HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_newWithRowsAndColumns" newWithRowsAndColumns' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_accessibleDescription" accessibleDescription' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardItem_accessibleText" accessibleText' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardItem_appendColumn" appendColumn' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_appendRowItems" appendRowItems' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_appendRowItem" appendRowItem' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_appendRows" appendRows' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_background" background' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M246.QBrushConst)
foreign import ccall "genpop__QStandardItem_checkState" checkState' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_child" child' ::  HoppyF.Ptr QStandardItemConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_childWithColumn" childWithColumn' ::  HoppyF.Ptr QStandardItemConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_clone" clone' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_column" column' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_columnCount" columnCount' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_getData" getData' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QStandardItem_getDataWithRole" getDataWithRole' ::  HoppyF.Ptr QStandardItemConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M168.QVariantConst)
foreign import ccall "genpop__QStandardItem_flags" flags' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_font" font' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M276.QFontConst)
foreign import ccall "genpop__QStandardItem_foreground" foreground' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M246.QBrushConst)
foreign import ccall "genpop__QStandardItem_hasChildren" hasChildren' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_icon" icon' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M288.QIconConst)
foreign import ccall "genpop__QStandardItem_index" index' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M92.QModelIndexConst)
foreign import ccall "genpop__QStandardItem_insertColumn" insertColumn' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_insertColumns" insertColumns' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_insertRowItems" insertRowItems' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_insertRowItem" insertRowItem' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyF.Ptr QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_insertRowsItems" insertRowsItems' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_insertRowsCount" insertRowsCount' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_isAutoTristate" isAutoTristate' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isCheckable" isCheckable' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isDragEnabled" isDragEnabled' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isDropEnabled" isDropEnabled' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isEditable" isEditable' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isEnabled" isEnabled' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isSelectable" isSelectable' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_isUserTristate" isUserTristate' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItem_model" model' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M328.QStandardItemModel)
foreign import ccall "genpop__QStandardItem_parent" parent' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_removeColumn" removeColumn' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_removeColumns" removeColumns' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_removeRow" removeRow' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_removeRows" removeRows' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_row" row' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_rowCount" rowCount' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_setAccessibleDescription" setAccessibleDescription' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setAccessibleText" setAccessibleText' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setAutoTristate" setAutoTristate' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setBackground" setBackground' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setCheckState" setCheckState' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setCheckable" setCheckable' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setChildWithColumn" setChildWithColumn' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setChild" setChild' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyF.Ptr QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setColumnCount" setColumnCount' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setData" setData' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M168.QVariantConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setDataWithRole" setDataWithRole' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M168.QVariantConst -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setDragEnabled" setDragEnabled' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setDropEnabled" setDropEnabled' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setEditable" setEditable' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setEnabled" setEnabled' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setFlags" setFlags' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setFont" setFont' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M276.QFontConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setForeground" setForeground' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M246.QBrushConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setIcon" setIcon' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M288.QIconConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setRowCount" setRowCount' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setSelectable" setSelectable' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setSizeHint" setSizeHint' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M134.QSizeConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setStatusTip" setStatusTip' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setText" setText' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setTextAlignment" setTextAlignment' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setToolTip" setToolTip' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setUserTristate" setUserTristate' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CBool -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_setWhatsThis" setWhatsThis' ::  HoppyF.Ptr QStandardItem -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_sizeHint" sizeHint' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M134.QSizeConst)
foreign import ccall "genpop__QStandardItem_sortChildren" sortChildren' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_sortChildrenWithOrder" sortChildrenWithOrder' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItem_statusTip" statusTip' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardItem_takeChild" takeChild' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_takeChildWithColumn" takeChildWithColumn' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItem)
foreign import ccall "genpop__QStandardItem_takeColumn" takeColumn' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItem_takeRow" takeRow' ::  HoppyF.Ptr QStandardItem -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItem_text" text' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardItem_textAlignment" textAlignment' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_toolTip" toolTip' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "genpop__QStandardItem_getType" getType' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItem_whatsThis" whatsThis' ::  HoppyF.Ptr QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M142.QStringConst)
foreign import ccall "gendel__QStandardItem" delete'QStandardItem :: HoppyF.Ptr QStandardItemConst -> HoppyP.IO ()
foreign import ccall "&gendel__QStandardItem" deletePtr'QStandardItem :: HoppyF.FunPtr (HoppyF.Ptr QStandardItemConst -> HoppyP.IO ())

class QStandardItemValue a where
  withQStandardItemPtr :: a -> (QStandardItemConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QStandardItemConstPtr a => QStandardItemValue a where
  withQStandardItemPtr = HoppyP.flip ($) . toQStandardItemConst

class (HoppyFHR.CppPtr this) => QStandardItemConstPtr this where
  toQStandardItemConst :: this -> QStandardItemConst

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

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

background :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M246.QBrush)
background arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M246.QBrushConst) =<<
  (background' arg'1')

checkState :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtCheckState)
checkState arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.toCppEnum
  ) =<<
  (checkState' arg'1')

child :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QStandardItem)
child arg'1 arg'2 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QStandardItem
  (child' arg'1' arg'2')

childWithColumn :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QStandardItem)
childWithColumn arg'1 arg'2 arg'3 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QStandardItem
  (childWithColumn' arg'1' arg'2' arg'3')

clone :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QStandardItem)
clone arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QStandardItem
  (clone' arg'1')

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

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

getData :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M168.QVariant)
getData arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (getData' arg'1')

getDataWithRole :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M168.QVariant)
getDataWithRole arg'1 arg'2 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M168.QVariantConst) =<<
  (getDataWithRole' arg'1' arg'2')

flags :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtItemFlags)
flags arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (flags' arg'1')

font :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M276.QFont)
font arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M276.QFontConst) =<<
  (font' arg'1')

foreground :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M246.QBrush)
foreground arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M246.QBrushConst) =<<
  (foreground' arg'1')

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

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

index :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M92.QModelIndex)
index arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (HoppyFHR.decodeAndDelete . M92.QModelIndexConst) =<<
  (index' arg'1')

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

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

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

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

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

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

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

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

model :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M328.QStandardItemModel)
model arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M328.QStandardItemModel
  (model' arg'1')

parent :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO QStandardItem)
parent arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap QStandardItem
  (parent' arg'1')

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

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

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

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

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

textAlignment :: (QStandardItemValue this) => (this) {- ^ this -} -> (HoppyP.IO M190.QtAlignment)
textAlignment arg'1 =
  withQStandardItemPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    QtahP.return . QtahFlags.numToFlags
  ) =<<
  (textAlignment' arg'1')

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

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

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

class (QStandardItemConstPtr this) => QStandardItemPtr this where
  toQStandardItem :: this -> QStandardItem

appendColumn :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendColumn arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M332.withQListQStandardItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendColumn' arg'1' arg'2')

appendRowItems :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendRowItems arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M332.withQListQStandardItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendRowItems' arg'1' arg'2')

appendRowItem :: (QStandardItemPtr this, QStandardItemPtr arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendRowItem arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  HoppyFHR.withCppPtr (toQStandardItem arg'2) $ \arg'2' ->
  (appendRowItem' arg'1' arg'2')

appendRows :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
appendRows arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M332.withQListQStandardItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (appendRows' arg'1' arg'2')

insertColumn :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertColumn arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M332.withQListQStandardItemPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insertColumn' arg'1' arg'2' arg'3')

insertColumns :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
insertColumns arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (insertColumns' arg'1' arg'2' arg'3')

insertRowItems :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertRowItems arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M332.withQListQStandardItemPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insertRowItems' arg'1' arg'2' arg'3')

insertRowItem :: (QStandardItemPtr this, QStandardItemPtr arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertRowItem arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (toQStandardItem arg'3) $ \arg'3' ->
  (insertRowItem' arg'1' arg'2' arg'3')

insertRowsItems :: (QStandardItemPtr this, M332.QListQStandardItemValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
insertRowsItems arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M332.withQListQStandardItemPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (insertRowsItems' arg'1' arg'2' arg'3')

insertRowsCount :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
insertRowsCount arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (insertRowsCount' arg'1' arg'2' arg'3')

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

removeColumns :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
removeColumns arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (removeColumns' arg'1' arg'2' arg'3')

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

removeRows :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO ())
removeRows arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (removeRows' arg'1' arg'2' arg'3')

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

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

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

setBackground :: (QStandardItemPtr this, M246.QBrushValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setBackground arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M246.withQBrushPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setBackground' arg'1' arg'2')

setCheckState :: (QStandardItemPtr this) => (this) {- ^ this -} -> (M190.QtCheckState) -> (HoppyP.IO ())
setCheckState arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'2 >>= \arg'2' ->
  (setCheckState' arg'1' arg'2')

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

setChildWithColumn :: (QStandardItemPtr this, QStandardItemPtr arg'4) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (arg'4) -> (HoppyP.IO ())
setChildWithColumn arg'1 arg'2 arg'3 arg'4 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyFHR.withCppPtr (toQStandardItem arg'4) $ \arg'4' ->
  (setChildWithColumn' arg'1' arg'2' arg'3' arg'4')

setChild :: (QStandardItemPtr this, QStandardItemPtr arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO ())
setChild arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (toQStandardItem arg'3) $ \arg'3' ->
  (setChild' arg'1' arg'2' arg'3')

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

setData :: (QStandardItemPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setData arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setData' arg'1' arg'2')

setDataWithRole :: (QStandardItemPtr this, M168.QVariantValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.Int) -> (HoppyP.IO ())
setDataWithRole arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M168.withQVariantPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  (setDataWithRole' arg'1' arg'2' arg'3')

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

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

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

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

setFlags :: (QStandardItemPtr this, M190.IsQtItemFlags arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFlags arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtItemFlags
  ) arg'2 >>= \arg'2' ->
  (setFlags' arg'1' arg'2')

setFont :: (QStandardItemPtr this, M276.QFontValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setFont arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M276.withQFontPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setFont' arg'1' arg'2')

setForeground :: (QStandardItemPtr this, M246.QBrushValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setForeground arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  M246.withQBrushPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setForeground' arg'1' arg'2')

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

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

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

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

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

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

setTextAlignment :: (QStandardItemPtr this, M190.IsQtAlignment arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setTextAlignment arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtAlignment
  ) arg'2 >>= \arg'2' ->
  (setTextAlignment' arg'1' arg'2')

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

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

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

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

sortChildrenWithOrder :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (M190.QtSortOrder) -> (HoppyP.IO ())
sortChildrenWithOrder arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.fromCppEnum
  ) arg'3 >>= \arg'3' ->
  (sortChildrenWithOrder' arg'1' arg'2' arg'3')

takeChild :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO QStandardItem)
takeChild arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QStandardItem
  (takeChild' arg'1' arg'2')

takeChildWithColumn :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QStandardItem)
takeChildWithColumn arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap QStandardItem
  (takeChildWithColumn' arg'1' arg'2' arg'3')

takeColumn :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO [QStandardItem])
takeColumn arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M332.QListQStandardItemConst) =<<
  (takeColumn' arg'1' arg'2')

takeRow :: (QStandardItemPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO [QStandardItem])
takeRow arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItem arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (HoppyFHR.decodeAndDelete . M332.QListQStandardItemConst) =<<
  (takeRow' arg'1' arg'2')

data QStandardItemConst =
    QStandardItemConst (HoppyF.Ptr QStandardItemConst)
  | QStandardItemConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardItemConst)
  deriving (HoppyP.Show)

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

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

castQStandardItemToConst :: QStandardItem -> QStandardItemConst
castQStandardItemToConst (QStandardItem ptr') = QStandardItemConst $ HoppyF.castPtr ptr'
castQStandardItemToConst (QStandardItemGc fptr' ptr') = QStandardItemConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QStandardItemConstPtr QStandardItemConst where
  toQStandardItemConst = HoppyP.id

data QStandardItem =
    QStandardItem (HoppyF.Ptr QStandardItem)
  | QStandardItemGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardItem)
  deriving (HoppyP.Show)

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

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

castQStandardItemToNonconst :: QStandardItemConst -> QStandardItem
castQStandardItemToNonconst (QStandardItemConst ptr') = QStandardItem $ HoppyF.castPtr ptr'
castQStandardItemToNonconst (QStandardItemConstGc fptr' ptr') = QStandardItemGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QStandardItemConstPtr QStandardItem where
  toQStandardItemConst (QStandardItem ptr') = QStandardItemConst $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItem -> HoppyF.Ptr QStandardItemConst) ptr'
  toQStandardItemConst (QStandardItemGc fptr' ptr') = QStandardItemConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItem -> HoppyF.Ptr QStandardItemConst) ptr'

instance QStandardItemPtr QStandardItem where
  toQStandardItem = HoppyP.id

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

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

newWithIconAndText :: (M288.QIconValue arg'1, M142.QStringValue arg'2) => (arg'1) -> (arg'2) -> (HoppyP.IO QStandardItem)
newWithIconAndText arg'1 arg'2 =
  M288.withQIconPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap QStandardItem
  (newWithIconAndText' arg'1' arg'2')

newWithRows :: (HoppyP.Int) -> (HoppyP.IO QStandardItem)
newWithRows arg'1 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  HoppyP.fmap QStandardItem
  (newWithRows' arg'1')

newWithRowsAndColumns :: (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO QStandardItem)
newWithRowsAndColumns arg'1 arg'2 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap QStandardItem
  (newWithRowsAndColumns' arg'1' arg'2')

class QStandardItemSuper a where
  downToQStandardItem :: a -> QStandardItem


class QStandardItemSuperConst a where
  downToQStandardItemConst :: a -> QStandardItemConst


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

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