QStandardItemModel.hs

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

module Graphics.UI.Qtah.Generated.Gui.QStandardItemModel (
  castQStandardItemModelToQAbstractItemModel,
  castQAbstractItemModelToQStandardItemModel,
  castQStandardItemModelToQObject,
  castQObjectToQStandardItemModel,
  QStandardItemModelValue (..),
  QStandardItemModelConstPtr (..),
  sortRole,
  findItems,
  findItemsWithFlags,
  findItemsWithFlagsAndColumn,
  horizontalHeaderItem,
  indexFromItem,
  invisibleRootItem,
  item,
  itemWithColumn,
  itemFromIndex,
  itemPrototype,
  verticalHeaderItem,
  QStandardItemModelPtr (..),
  setSortRole,
  appendColumn,
  appendRowItems,
  appendRowItem,
  clear,
  insertColumnWithItems,
  insertColumn,
  insertColumnWithParent,
  insertRowWithItems,
  insertRowWithItem,
  insertRow,
  insertRowWithParent,
  setColumnCount,
  setHorizontalHeaderItem,
  setHorizontalHeaderLabels,
  setItemWithColumn,
  setItem,
  setItemPrototype,
  setRowCount,
  setVerticalHeaderItem,
  setVerticalHeaderLabels,
  takeColumn,
  takeHorizontalHeaderItem,
  takeItem,
  takeItemWithColumn,
  takeRow,
  takeVerticalHeaderItem,
  QStandardItemModelConst (..),
  castQStandardItemModelToConst,
  QStandardItemModel (..),
  castQStandardItemModelToNonconst,
  new,
  newWithParent,
  newWithRowsAndColumns,
  newWithRowsAndColumnsAndParent,
  QStandardItemModelSuper (..),
  QStandardItemModelSuperConst (..),
  ) where

import qualified Foreign as HoppyF
import qualified Foreign.C as HoppyFC
import qualified Foreign.Hoppy.Runtime as HoppyFHR
import qualified Graphics.UI.Qtah.Flags as QtahFlags
import qualified Graphics.UI.Qtah.Generated.Core.QAbstractItemModel as M4
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.QObject as M94
import qualified Graphics.UI.Qtah.Generated.Core.QString as M142
import qualified Graphics.UI.Qtah.Generated.Core.QStringList as M144
import qualified Graphics.UI.Qtah.Generated.Core.Types as M190
import {-# SOURCE #-} qualified Graphics.UI.Qtah.Generated.Gui.QStandardItem as M330
import Prelude (($), (.), (/=), (=<<), (==), (>>=))
import qualified Prelude as HoppyP
import qualified Prelude as QtahP

foreign import ccall "genpop__QStandardItemModel_new" new' ::  HoppyP.IO (HoppyF.Ptr QStandardItemModel)
foreign import ccall "genpop__QStandardItemModel_newWithParent" newWithParent' ::  HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QStandardItemModel)
foreign import ccall "genpop__QStandardItemModel_newWithRowsAndColumns" newWithRowsAndColumns' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr QStandardItemModel)
foreign import ccall "genpop__QStandardItemModel_newWithRowsAndColumnsAndParent" newWithRowsAndColumnsAndParent' ::  HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M94.QObject -> HoppyP.IO (HoppyF.Ptr QStandardItemModel)
foreign import ccall "genpop__QStandardItemModel_sortRole" sortRole' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyP.IO HoppyFC.CInt
foreign import ccall "genpop__QStandardItemModel_setSortRole" setSortRole' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_appendColumn" appendColumn' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_appendRowItems" appendRowItems' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_appendRowItem" appendRowItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_clear" clear' ::  HoppyF.Ptr QStandardItemModel -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_findItems" findItems' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M142.QStringConst -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_findItemsWithFlags" findItemsWithFlags' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_findItemsWithFlagsAndColumn" findItemsWithFlagsAndColumn' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M142.QStringConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_horizontalHeaderItem" horizontalHeaderItem' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_indexFromItem" indexFromItem' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M330.QStandardItemConst -> HoppyP.IO (HoppyF.Ptr M92.QModelIndexConst)
foreign import ccall "genpop__QStandardItemModel_insertColumnWithItems" insertColumnWithItems' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_insertColumn" insertColumn' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItemModel_insertColumnWithParent" insertColumnWithParent' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItemModel_insertRowWithItems" insertRowWithItems' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M332.QListQStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_insertRowWithItem" insertRowWithItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_insertRow" insertRow' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItemModel_insertRowWithParent" insertRowWithParent' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO HoppyFC.CBool
foreign import ccall "genpop__QStandardItemModel_invisibleRootItem" invisibleRootItem' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_item" item' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_itemWithColumn" itemWithColumn' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_itemFromIndex" itemFromIndex' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M92.QModelIndexConst -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_itemPrototype" itemPrototype' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyP.IO (HoppyF.Ptr M330.QStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_setColumnCount" setColumnCount' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setHorizontalHeaderItem" setHorizontalHeaderItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setHorizontalHeaderLabels" setHorizontalHeaderLabels' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setItemWithColumn" setItemWithColumn' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setItem" setItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setItemPrototype" setItemPrototype' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M330.QStandardItemConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setRowCount" setRowCount' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setVerticalHeaderItem" setVerticalHeaderItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyF.Ptr M330.QStandardItem -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_setVerticalHeaderLabels" setVerticalHeaderLabels' ::  HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr M144.QStringListConst -> HoppyP.IO ()
foreign import ccall "genpop__QStandardItemModel_takeColumn" takeColumn' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_takeHorizontalHeaderItem" takeHorizontalHeaderItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_takeItem" takeItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_takeItemWithColumn" takeItemWithColumn' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_takeRow" takeRow' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M332.QListQStandardItemConst)
foreign import ccall "genpop__QStandardItemModel_takeVerticalHeaderItem" takeVerticalHeaderItem' ::  HoppyF.Ptr QStandardItemModel -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "genpop__QStandardItemModel_verticalHeaderItem" verticalHeaderItem' ::  HoppyF.Ptr QStandardItemModelConst -> HoppyFC.CInt -> HoppyP.IO (HoppyF.Ptr M330.QStandardItem)
foreign import ccall "gencast__QStandardItemModel__QAbstractItemModel" castQStandardItemModelToQAbstractItemModel :: HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M4.QAbstractItemModelConst
foreign import ccall "gencast__QAbstractItemModel__QStandardItemModel" castQAbstractItemModelToQStandardItemModel :: HoppyF.Ptr M4.QAbstractItemModelConst -> HoppyF.Ptr QStandardItemModelConst
foreign import ccall "gencast__QStandardItemModel__QObject" castQStandardItemModelToQObject :: HoppyF.Ptr QStandardItemModelConst -> HoppyF.Ptr M94.QObjectConst
foreign import ccall "gencast__QObject__QStandardItemModel" castQObjectToQStandardItemModel :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr QStandardItemModelConst
foreign import ccall "gendel__QStandardItemModel" delete'QStandardItemModel :: HoppyF.Ptr QStandardItemModelConst -> HoppyP.IO ()
foreign import ccall "&gendel__QStandardItemModel" deletePtr'QStandardItemModel :: HoppyF.FunPtr (HoppyF.Ptr QStandardItemModelConst -> HoppyP.IO ())

class QStandardItemModelValue a where
  withQStandardItemModelPtr :: a -> (QStandardItemModelConst -> HoppyP.IO b) -> HoppyP.IO b

instance {-# OVERLAPPABLE #-} QStandardItemModelConstPtr a => QStandardItemModelValue a where
  withQStandardItemModelPtr = HoppyP.flip ($) . toQStandardItemModelConst

class (M4.QAbstractItemModelConstPtr this) => QStandardItemModelConstPtr this where
  toQStandardItemModelConst :: this -> QStandardItemModelConst

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

findItems :: (QStandardItemModelValue this, M142.QStringValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO [M330.QStandardItem])
findItems arg'1 arg'2 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (HoppyFHR.decodeAndDelete . M332.QListQStandardItemConst) =<<
  (findItems' arg'1' arg'2')

findItemsWithFlags :: (QStandardItemModelValue this, M142.QStringValue arg'2, M190.IsQtMatchFlags arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.IO [M330.QStandardItem])
findItemsWithFlags arg'1 arg'2 arg'3 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtMatchFlags
  ) arg'3 >>= \arg'3' ->
  (HoppyFHR.decodeAndDelete . M332.QListQStandardItemConst) =<<
  (findItemsWithFlags' arg'1' arg'2' arg'3')

findItemsWithFlagsAndColumn :: (QStandardItemModelValue this, M142.QStringValue arg'2, M190.IsQtMatchFlags arg'3) => (this) {- ^ this -} -> (arg'2) -> (arg'3) -> (HoppyP.Int) -> (HoppyP.IO [M330.QStandardItem])
findItemsWithFlagsAndColumn arg'1 arg'2 arg'3 arg'4 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M142.withQStringPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (
    QtahP.return . QtahFlags.flagsToNum . M190.toQtMatchFlags
  ) arg'3 >>= \arg'3' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'4 >>= \arg'4' ->
  (HoppyFHR.decodeAndDelete . M332.QListQStandardItemConst) =<<
  (findItemsWithFlagsAndColumn' arg'1' arg'2' arg'3' arg'4')

horizontalHeaderItem :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
horizontalHeaderItem arg'1 arg'2 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (horizontalHeaderItem' arg'1' arg'2')

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

invisibleRootItem :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.IO M330.QStandardItem)
invisibleRootItem arg'1 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M330.QStandardItem
  (invisibleRootItem' arg'1')

item :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
item arg'1 arg'2 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (item' arg'1' arg'2')

itemWithColumn :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
itemWithColumn arg'1 arg'2 arg'3 =
  withQStandardItemModelPtr 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 M330.QStandardItem
  (itemWithColumn' arg'1' arg'2' arg'3')

itemFromIndex :: (QStandardItemModelValue this, M92.QModelIndexValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO M330.QStandardItem)
itemFromIndex arg'1 arg'2 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  M92.withQModelIndexPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (itemFromIndex' arg'1' arg'2')

itemPrototype :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.IO M330.QStandardItemConst)
itemPrototype arg'1 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  HoppyP.fmap M330.QStandardItemConst
  (itemPrototype' arg'1')

verticalHeaderItem :: (QStandardItemModelValue this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
verticalHeaderItem arg'1 arg'2 =
  withQStandardItemModelPtr arg'1 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (verticalHeaderItem' arg'1' arg'2')

class (QStandardItemModelConstPtr this, M4.QAbstractItemModelPtr this) => QStandardItemModelPtr this where
  toQStandardItemModel :: this -> QStandardItemModel

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

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

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

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

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

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

insertColumn :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
insertColumn arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (insertColumn' arg'1' arg'2')

insertColumnWithParent :: (QStandardItemModelPtr this, M92.QModelIndexValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
insertColumnWithParent arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M92.withQModelIndexPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (insertColumnWithParent' arg'1' arg'2' arg'3')

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

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

insertRow :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO HoppyP.Bool)
insertRow arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (insertRow' arg'1' arg'2')

insertRowWithParent :: (QStandardItemModelPtr this, M92.QModelIndexValue arg'3) => (this) {- ^ this -} -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO HoppyP.Bool)
insertRowWithParent arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  M92.withQModelIndexPtr arg'3 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'3' ->
  (
    (HoppyP.return . (/= 0))
  ) =<<
  (insertRowWithParent' arg'1' arg'2' arg'3')

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

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

setHorizontalHeaderLabels :: (QStandardItemModelPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setHorizontalHeaderLabels arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setHorizontalHeaderLabels' arg'1' arg'2')

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

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

setItemPrototype :: (QStandardItemModelPtr this, M330.QStandardItemValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setItemPrototype arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  M330.withQStandardItemPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setItemPrototype' arg'1' arg'2')

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

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

setVerticalHeaderLabels :: (QStandardItemModelPtr this, M144.QStringListValue arg'2) => (this) {- ^ this -} -> (arg'2) -> (HoppyP.IO ())
setVerticalHeaderLabels arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  M144.withQStringListPtr arg'2 $ HoppyP.flip HoppyFHR.withCppPtr $ \arg'2' ->
  (setVerticalHeaderLabels' arg'1' arg'2')

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

takeHorizontalHeaderItem :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
takeHorizontalHeaderItem arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (takeHorizontalHeaderItem' arg'1' arg'2')

takeItem :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
takeItem arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (takeItem' arg'1' arg'2')

takeItemWithColumn :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
takeItemWithColumn arg'1 arg'2 arg'3 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'3 >>= \arg'3' ->
  HoppyP.fmap M330.QStandardItem
  (takeItemWithColumn' arg'1' arg'2' arg'3')

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

takeVerticalHeaderItem :: (QStandardItemModelPtr this) => (this) {- ^ this -} -> (HoppyP.Int) -> (HoppyP.IO M330.QStandardItem)
takeVerticalHeaderItem arg'1 arg'2 =
  HoppyFHR.withCppPtr (toQStandardItemModel arg'1) $ \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyP.fmap M330.QStandardItem
  (takeVerticalHeaderItem' arg'1' arg'2')

data QStandardItemModelConst =
    QStandardItemModelConst (HoppyF.Ptr QStandardItemModelConst)
  | QStandardItemModelConstGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardItemModelConst)
  deriving (HoppyP.Show)

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

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

castQStandardItemModelToConst :: QStandardItemModel -> QStandardItemModelConst
castQStandardItemModelToConst (QStandardItemModel ptr') = QStandardItemModelConst $ HoppyF.castPtr ptr'
castQStandardItemModelToConst (QStandardItemModelGc fptr' ptr') = QStandardItemModelConstGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QStandardItemModelConstPtr QStandardItemModelConst where
  toQStandardItemModelConst = HoppyP.id

instance M4.QAbstractItemModelConstPtr QStandardItemModelConst where
  toQAbstractItemModelConst (QStandardItemModelConst ptr') = M4.QAbstractItemModelConst $ castQStandardItemModelToQAbstractItemModel ptr'
  toQAbstractItemModelConst (QStandardItemModelConstGc fptr' ptr') = M4.QAbstractItemModelConstGc fptr' $ castQStandardItemModelToQAbstractItemModel ptr'

instance M94.QObjectConstPtr QStandardItemModelConst where
  toQObjectConst (QStandardItemModelConst ptr') = M94.QObjectConst $ castQStandardItemModelToQObject ptr'
  toQObjectConst (QStandardItemModelConstGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQStandardItemModelToQObject ptr'

data QStandardItemModel =
    QStandardItemModel (HoppyF.Ptr QStandardItemModel)
  | QStandardItemModelGc (HoppyF.ForeignPtr ()) (HoppyF.Ptr QStandardItemModel)
  deriving (HoppyP.Show)

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

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

castQStandardItemModelToNonconst :: QStandardItemModelConst -> QStandardItemModel
castQStandardItemModelToNonconst (QStandardItemModelConst ptr') = QStandardItemModel $ HoppyF.castPtr ptr'
castQStandardItemModelToNonconst (QStandardItemModelConstGc fptr' ptr') = QStandardItemModelGc fptr' $ HoppyF.castPtr ptr'

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

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

instance QStandardItemModelConstPtr QStandardItemModel where
  toQStandardItemModelConst (QStandardItemModel ptr') = QStandardItemModelConst $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'
  toQStandardItemModelConst (QStandardItemModelGc fptr' ptr') = QStandardItemModelConstGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'

instance QStandardItemModelPtr QStandardItemModel where
  toQStandardItemModel = HoppyP.id

instance M4.QAbstractItemModelConstPtr QStandardItemModel where
  toQAbstractItemModelConst (QStandardItemModel ptr') = M4.QAbstractItemModelConst $ castQStandardItemModelToQAbstractItemModel $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'
  toQAbstractItemModelConst (QStandardItemModelGc fptr' ptr') = M4.QAbstractItemModelConstGc fptr' $ castQStandardItemModelToQAbstractItemModel $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'

instance M4.QAbstractItemModelPtr QStandardItemModel where
  toQAbstractItemModel (QStandardItemModel ptr') = M4.QAbstractItemModel $ (HoppyF.castPtr :: HoppyF.Ptr M4.QAbstractItemModelConst -> HoppyF.Ptr M4.QAbstractItemModel) $ castQStandardItemModelToQAbstractItemModel $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'
  toQAbstractItemModel (QStandardItemModelGc fptr' ptr') = M4.QAbstractItemModelGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M4.QAbstractItemModelConst -> HoppyF.Ptr M4.QAbstractItemModel) $ castQStandardItemModelToQAbstractItemModel $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'

instance M94.QObjectConstPtr QStandardItemModel where
  toQObjectConst (QStandardItemModel ptr') = M94.QObjectConst $ castQStandardItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'
  toQObjectConst (QStandardItemModelGc fptr' ptr') = M94.QObjectConstGc fptr' $ castQStandardItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'

instance M94.QObjectPtr QStandardItemModel where
  toQObject (QStandardItemModel ptr') = M94.QObject $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQStandardItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'
  toQObject (QStandardItemModelGc fptr' ptr') = M94.QObjectGc fptr' $ (HoppyF.castPtr :: HoppyF.Ptr M94.QObjectConst -> HoppyF.Ptr M94.QObject) $ castQStandardItemModelToQObject $ (HoppyF.castPtr :: HoppyF.Ptr QStandardItemModel -> HoppyF.Ptr QStandardItemModelConst) ptr'

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

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

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

newWithRowsAndColumnsAndParent :: (M94.QObjectPtr arg'3) => (HoppyP.Int) -> (HoppyP.Int) -> (arg'3) -> (HoppyP.IO QStandardItemModel)
newWithRowsAndColumnsAndParent arg'1 arg'2 arg'3 =
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'1 >>= \arg'1' ->
  (
    HoppyP.return . HoppyFHR.coerceIntegral
  ) arg'2 >>= \arg'2' ->
  HoppyFHR.withCppPtr (M94.toQObject arg'3) $ \arg'3' ->
  HoppyP.fmap QStandardItemModel
  (newWithRowsAndColumnsAndParent' arg'1' arg'2' arg'3')

class QStandardItemModelSuper a where
  downToQStandardItemModel :: a -> QStandardItemModel

instance QStandardItemModelSuper M4.QAbstractItemModel where
  downToQStandardItemModel = castQStandardItemModelToNonconst . cast' . M4.castQAbstractItemModelToConst
    where
      cast' (M4.QAbstractItemModelConst ptr') = QStandardItemModelConst $ castQAbstractItemModelToQStandardItemModel ptr'
      cast' (M4.QAbstractItemModelConstGc fptr' ptr') = QStandardItemModelConstGc fptr' $ castQAbstractItemModelToQStandardItemModel ptr'
instance QStandardItemModelSuper M94.QObject where
  downToQStandardItemModel = castQStandardItemModelToNonconst . cast' . M94.castQObjectToConst
    where
      cast' (M94.QObjectConst ptr') = QStandardItemModelConst $ castQObjectToQStandardItemModel ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QStandardItemModelConstGc fptr' $ castQObjectToQStandardItemModel ptr'

class QStandardItemModelSuperConst a where
  downToQStandardItemModelConst :: a -> QStandardItemModelConst

instance QStandardItemModelSuperConst M4.QAbstractItemModelConst where
  downToQStandardItemModelConst = cast'
    where
      cast' (M4.QAbstractItemModelConst ptr') = QStandardItemModelConst $ castQAbstractItemModelToQStandardItemModel ptr'
      cast' (M4.QAbstractItemModelConstGc fptr' ptr') = QStandardItemModelConstGc fptr' $ castQAbstractItemModelToQStandardItemModel ptr'
instance QStandardItemModelSuperConst M94.QObjectConst where
  downToQStandardItemModelConst = cast'
    where
      cast' (M94.QObjectConst ptr') = QStandardItemModelConst $ castQObjectToQStandardItemModel ptr'
      cast' (M94.QObjectConstGc fptr' ptr') = QStandardItemModelConstGc fptr' $ castQObjectToQStandardItemModel ptr'

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

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