{-# LINE 2 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
-- -*-haskell-*-
-- GIMP Toolkit (GTK) TreeModel
--
-- Author : Axel Simon
--
-- Created: 8 May 2001
--
-- Copyright (C) 1999-2007 Axel Simon
--
-- This library is free software; you can redistribute it and/or
-- modify it under the terms of the GNU Lesser General Public
-- License as published by the Free Software Foundation; either
-- version 2.1 of the License, or (at your option) any later version.
--
-- This library is distributed in the hope that it will be useful,
-- but WITHOUT ANY WARRANTY; without even the implied warranty of
-- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-- Lesser General Public License for more details.
--
-- |
-- Maintainer : gtk2hs-users@lists.sourceforge.net
-- Stability : provisional
-- Portability : portable (depends on GHC)
--
-- The tree interface used by 'TreeView'.
--
module Graphics.UI.Gtk.ModelView.TreeModel (
-- * Detail
--
-- | The 'TreeModel' interface defines a generic storage object for use by the
-- 'TreeView' and similar widgets. Specifically, the functions in defined here
-- are used by Gtk's widgets to access the stored data. Thus, rather than
-- calling these functions, an application programmer has to implement them.
-- While the module "Graphics.UI.Gtk.ModelView.CustomStore" provides the
-- necessary functions to implement the 'TreeMode' interface, it is often
-- sufficient to use the wo implementations that come with Gtk2Hs, namely are
-- 'ListStore' and 'TreeStore'.
--
-- The model is represented as a hierarchical tree of values. It is important
-- to note that this interface only provides a way of examining a model and
-- observing changes. The implementation of each individual model decides how
-- and if changes are made.
--
-- Two generic models are provided that implement the 'TreeModel' interface:
-- the 'TreeStore' and the 'ListStore'. To use these, the developer simply
-- inserts data into these models as necessary. These models provide the data
-- structure as well as the 'TreeModel' interface. In fact, they implement
-- other interfaces, making drag and drop and storing data trivial.
--
-- A 'TreeModel' stores records of the same type. Each record is referred to
-- as row, just like in a relational database. Defining how the information of
-- a row is displayed can be done in two ways: If the widget displays data
-- using 'Graphics.UI.Gtk.ModelView.CellRenderer.CellRenderer' or one of its
-- derivatives, it is possible to state how a row is mapped to the attributes
-- of a renderer using the
-- 'Graphics.UI.Gtk.ModelView.CellLayout.cellLayoutSetAttributes' function.
-- Some widgets do not use
-- 'Graphics.UI.Gtk.ModelView.CellRenderer.CellRenderer's to display their
-- data. In this case an extraction function can be defined that maps a row to
-- one of a few basic types (like 'String's or 'Int's). This extraction
-- function is associated with a 'ColumnId' using
-- 'Graphics.UI.Gtk.ModelView.CustomStore.treeModelSetColumn'. The latter can
-- be set in the widget for the property that should be set. The widget then
-- uses the function 'treeModelGetValue' and the 'ColumnId' to extract the
-- value from the model. As the name suggests, using 'ColumnId's creates a
-- view of the data as if each row were divided into a well-defined set of
-- columns, again, like a relational database.
--
-- Models are accessed on a node level of granularity. There are two index
-- types used to reference a particular node in a model. They are the
-- 'TreePath' and the 'TreeIter'. Most of the interface consists of operations
-- on a 'TreeIter'.
--
-- A path is essentially a potential node. It is a location on a model that
-- may or may not actually correspond to a node on a specific model. A
-- 'TreePath' is in fact a synonym for a list of 'Int's and hence are easy to
-- manipulate. Each number refers to the offset at that level. Thus, the path
-- @[0]@ refers to the root node and the path @[2,4]@ refers to the fifth
-- child of the third node.
--
-- By contrast, a 'TreeIter' is a reference to a specific node on a specific
-- model. It is an abstract data type filled in by the model. One can convert
-- a path to an iterator by calling 'treeModelGetIter'. These iterators are
-- the primary way of accessing a model and are similar to the iterators used
-- by 'TextBuffer'. The model interface defines a set of operations using them
-- for navigating the model. Iterators are expected to always be valid for as
-- long as the model is unchanged (and doesn't emit a signal).
--

-- * Class Hierarchy
-- |
-- @
-- | GInterface
-- | +----TreeModel
-- | +--------TypedTreeModel
-- @

-- * Types
  TreeModel,
  TreeModelClass,
  castToTreeModel, gTypeTreeModel,
  toTreeModel,

  TypedTreeModel,
  TypedTreeModelClass,
  toTypedTreeModel,

  TreeIter(..),
  TreePath,

  ColumnId,

-- * Constructors
  makeColumnIdInt,
  makeColumnIdBool,
  makeColumnIdString,
  makeColumnIdPixbuf,
  invalidColumnId,

-- * Methods
  columnIdToNumber,
  stringToTreePath,
  treeModelGetFlags,
  treeModelGetIter,
  treeModelGetIterFromString,
  treeModelGetIterFirst,
  treeModelGetPath,
  treeModelGetValue,
  treeModelIterNext,
  treeModelIterChildren,
  treeModelIterHasChild,
  treeModelIterNChildren,
  treeModelIterNthChild,
  treeModelIterParent,
  treeModelForeach,

  treeModelGetStringFromIter,

  treeModelRefNode,
  treeModelUnrefNode,
  treeModelRowChanged,
  treeModelRowInserted,
  treeModelRowHasChildToggled,
  treeModelRowDeleted,
  treeModelRowsReordered,

-- * Signals
  rowChanged,
  rowInserted,
  rowHasChildToggled,
  rowDeleted,
  rowsReordered,

  ) where

import Control.Monad (liftM)

import System.Glib.FFI
import System.Glib.Flags (toFlags)
import System.Glib.UTFString
import Graphics.UI.Gtk.Signals
{-# LINE 163 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
import Graphics.UI.Gtk.Types
{-# LINE 164 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
import System.Glib.StoreValue (TMType, GenericValue,
      valueGetGenericValue)
import System.Glib.GValue (GValue(GValue), allocaGValue)
import Graphics.UI.Gtk.ModelView.CustomStore (TreeModelFlags(..),
                                                  treeModelGetRow)
import Graphics.UI.Gtk.ModelView.Types (TypedTreeModel,
                                             TypedTreeModelClass,
                                             toTypedTreeModel,
                                             TreeIter(..),
                                             receiveTreeIter,
                                             peekTreeIter,
                                             TreePath,
                                             NativeTreePath(..),
                                             withTreePath,
                                             fromTreePath,
                                             peekTreePath,
                                             stringToTreePath,
                                             ColumnId(..),
                                             ColumnAccess(..))
import System.Glib.GValueTypes ( valueGetInt, valueGetBool,
                                     valueGetString, valueGetGObject )

{-# LINE 186 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}

--------------------
-- Constructors


-- | Create a 'ColumnId' to extract an integer.
makeColumnIdInt :: Int -> ColumnId row Int
makeColumnIdInt = ColumnId valueGetInt CAInt

-- | Create a 'ColumnId' to extract an Boolean.
makeColumnIdBool :: Int -> ColumnId row Bool
makeColumnIdBool = ColumnId valueGetBool CABool

-- | Create a 'ColumnId' to extract an string.
makeColumnIdString :: Int -> ColumnId row String
makeColumnIdString = ColumnId valueGetString CAString

-- | Create a 'ColumnId' to extract an 'Pixbuf'.
makeColumnIdPixbuf :: Int -> ColumnId row Pixbuf
makeColumnIdPixbuf = ColumnId valueGetGObject CAPixbuf

-- | Convert a 'ColumnId' to a bare number.
columnIdToNumber :: ColumnId row ty -> Int
columnIdToNumber (ColumnId _ _ i) = i

-- | The invalid 'ColumnId'. Widgets use this value if no column id has
-- been set.
invalidColumnId :: ColumnId row ty
invalidColumnId = ColumnId (error "invalidColumnId: no GValue extractor")
  (error "invalidColumnId: no access type") (-1)

instance Eq (ColumnId row ty) where
  (ColumnId _ _ i1) == (ColumnId _ _ i2) = i1==i2

instance Show (ColumnId row ty) where
  show (ColumnId _ _ i) = show i


--------------------
-- Methods

-- %hash d:35ea
-- | Returns a set of flags supported by this interface.
--
-- The flags supported should not
-- change during the lifecycle of the tree_model.
--
treeModelGetFlags :: TreeModelClass self => self -> IO [TreeModelFlags]
treeModelGetFlags self =
  liftM (toFlags . fromIntegral) $
  (\(TreeModel arg1) -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_flags argPtr1)
{-# LINE 237 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)

-- %hash c:35a1 d:49a2
-- | Turn a 'String' into a 'TreeIter'.
--
-- * Returns @Nothing@ if the string is not a colon separated list of numbers
-- that references a valid node.
--
treeModelGetIterFromString :: TreeModelClass self => self
 -> String -- ^ @pathString@ - A string representation of a 'TreePath'.
 -> IO (Maybe TreeIter)
treeModelGetIterFromString self pathString =
  receiveTreeIter $ \iterPtr ->
  withUTFString pathString $ \pathStringPtr ->
  (\(TreeModel arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_iter_from_string argPtr1 arg2 arg3)
{-# LINE 252 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    pathStringPtr

-- %hash c:4cd2 d:ad96
-- | Turn a 'TreePath' into a 'TreeIter'.
--
-- Returns @Nothing@ if the given 'TreePath' was invalid. The empty list
-- is always invalid. The root node of a tree can be accessed by passing
-- @[0]@ as @path@.
--
treeModelGetIter :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - The 'TreePath'.
 -> IO (Maybe TreeIter)
treeModelGetIter _ [] = return Nothing
treeModelGetIter self path =
  receiveTreeIter $ \iterPtr ->
  withTreePath path $ \path ->
  (\(TreeModel arg1) arg2 (NativeTreePath arg3) -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_iter argPtr1 arg2 arg3)
{-# LINE 271 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    path

-- %hash c:103f d:8041
-- | Retrieves an 'TreeIter' to the first entry.
--
-- Returns @Nothing@ if the table is empty.
--
treeModelGetIterFirst :: TreeModelClass self => self
 -> IO (Maybe TreeIter)
treeModelGetIterFirst self =
  receiveTreeIter $ \iterPtr ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_iter_first argPtr1 arg2)
{-# LINE 285 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr

-- %hash c:ec20 d:d43e
-- | Turn an abstract 'TreeIter' into a 'TreePath'.
--
-- In case the given 'TreeIter' was invalid, an empty list is returned.
--
treeModelGetPath :: TreeModelClass self => self
 -> TreeIter -> IO TreePath
treeModelGetPath self iter =
  with iter $ \iterPtr ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_path argPtr1 arg2)
{-# LINE 298 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
  >>= fromTreePath

-- | Read the value of at a specific column and 'TreeIter'.
--
treeModelGetValue :: TreeModelClass self => self
 -> TreeIter
 -> ColumnId row ty -- ^ @column@ - The column to lookup the value at.
 -> IO ty
treeModelGetValue self iter (ColumnId getter _ colId) =
  allocaGValue $ \gVal ->
  with iter $ \iterPtr -> do
  (\(TreeModel arg1) arg2 arg3 (GValue arg4) -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_value argPtr1 arg2 arg3 arg4)
{-# LINE 312 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    (fromIntegral colId)
    gVal
  getter gVal

-- %hash c:5c12 d:d7db
-- | Retrieve an iterator to the node following it at the current level. If
-- there is no next node, @Nothing@ is returned.
--
treeModelIterNext :: TreeModelClass self => self -> TreeIter -> IO (Maybe TreeIter)
treeModelIterNext self iter =
  receiveTreeIter $ \iterPtr -> do
  poke iterPtr iter
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_next argPtr1 arg2)
{-# LINE 327 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr

-- %hash c:7eba d:27e8
-- | Retrieve an iterator to the first child of @parent@. If @parent@ has no
-- children, @Nothing@.
--
treeModelIterChildren :: TreeModelClass self => self
 -> TreeIter -- ^ @parent@ - a pointer to the parent
 -> IO (Maybe TreeIter)
treeModelIterChildren self parent =
  receiveTreeIter $ \iterPtr ->
  with parent $ \parentPtr ->
  (\(TreeModel arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_children argPtr1 arg2 arg3)
{-# LINE 341 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    parentPtr

-- %hash c:dcc3
-- | Returns @True@ if @iter@ has children, @False@ otherwise.
--
treeModelIterHasChild :: TreeModelClass self => self
 -> TreeIter -- ^ @iter@ - The 'TreeIter' to test for children.
 -> IO Bool -- ^ returns @True@ if @iter@ has children.
treeModelIterHasChild self iter =
  liftM toBool $
  with iter $ \iterPtr ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_has_child argPtr1 arg2)
{-# LINE 355 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr

-- %hash c:eed
-- | Returns the number of children that @iter@ has. As a special case, if
-- @iter@ is @Nothing@, then the number of toplevel nodes is returned.
--
treeModelIterNChildren :: TreeModelClass self => self
 -> Maybe TreeIter -- ^ @iter@ - The 'TreeIter', or @Nothing@.
 -> IO Int -- ^ returns The number of children of @iter@.
treeModelIterNChildren self iter =
  liftM fromIntegral $
  maybeWith with iter $ \iterPtr ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_n_children argPtr1 arg2)
{-# LINE 369 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr

-- %hash c:6950 d:6f4d
-- | Retrieve the @n@th child of @parent@, counting from zero. If @n@ is too
-- big or @parent@ has no children, @Nothing@ is returned. If @Nothing@ is
-- specified for the @parent@ argument, the function will return the @n@th
-- root node.
--
treeModelIterNthChild :: TreeModelClass self => self
 -> Maybe TreeIter -- ^ @parent@ - The 'TreeIter' to get the child from, or
                   -- @Nothing@.
 -> Int -- ^ @n@ - Then index of the desired child.
 -> IO (Maybe TreeIter)
treeModelIterNthChild self parent n =
  receiveTreeIter $ \iterPtr ->
  maybeWith with parent $ \parentPtr ->
  (\(TreeModel arg1) arg2 arg3 arg4 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_nth_child argPtr1 arg2 arg3 arg4)
{-# LINE 387 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    parentPtr
    (fromIntegral n)

-- %hash c:8f01 d:70ff
-- | Retrieve the parent of this iterator.
--
treeModelIterParent :: TreeModelClass self => self
 -> TreeIter
 -> IO (Maybe TreeIter)
treeModelIterParent self child =
  receiveTreeIter $ \iterPtr ->
  with child $ \childPtr ->
  (\(TreeModel arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_iter_parent argPtr1 arg2 arg3)
{-# LINE 402 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iterPtr
    childPtr

-- %hash c:154f d:a6d
-- | Maps a function over each node in model in a depth-first fashion. If it
-- returns @True@, then the tree ceases to be walked, and 'treeModelForeach'
-- returns.
--
treeModelForeach :: TreeModelClass self => self -> (TreeIter -> IO Bool) -> IO ()
treeModelForeach self fun = do
  fPtr <- mkTreeModelForeachFunc (\_ _ iterPtr _ -> do
    -- make a deep copy of the iterator. This makes it possible to store this
    -- iterator in Haskell land somewhere. The TreeModel parameter is not
    -- passed to the function due to performance reasons. But since it is
    -- a constant this does not matter.
    iter <- peek iterPtr
    liftM (fromIntegral.fromBool) $ fun iter
    )
  (\(TreeModel arg1) arg2 arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_foreach argPtr1 arg2 arg3)
{-# LINE 422 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    fPtr
    nullPtr
  freeHaskellFunPtr fPtr

type TreeModelForeachFunc = FunPtr (((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> ((Ptr ()) -> (IO CInt))))))
{-# LINE 428 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}

foreign import ccall "wrapper" mkTreeModelForeachFunc ::
  (Ptr () -> Ptr () -> Ptr TreeIter -> Ptr () -> IO CInt) ->
  IO TreeModelForeachFunc


-- %hash c:f04a d:94fd
-- | Generates a string representation of the iter. This string is a \':\'
-- separated list of numbers. For example, \"4:10:0:3\" would be an acceptable
-- return value for this string.
--
-- * Available since Gtk+ version 2.2
--
treeModelGetStringFromIter :: TreeModelClass self => self
 -> TreeIter -- ^ @iter@ - An 'TreeIter'.
 -> IO String -- ^ the returned string representation
treeModelGetStringFromIter self iter = with iter $ \iter ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_get_string_from_iter argPtr1 arg2)
{-# LINE 446 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iter
  >>= readUTFString


-- %hash c:228e d:304e
-- | Lets the tree ref the node. This is an optional method for models to
-- implement. To be more specific, models may ignore this call as it exists
-- primarily for performance reasons.
--
-- This function is primarily meant as a way for views to let caching model
-- know when nodes are being displayed (and hence, whether or not to cache that
-- node.) For example, a file-system based model would not want to keep the
-- entire file-hierarchy in memory, just the sections that are currently being
-- displayed by every current view.
--
-- A model should be expected to be able to get an iter independent of its
-- reffed state.
--
treeModelRefNode :: TreeModelClass self => self
 -> TreeIter -- ^ @iter@ - The 'TreeIter'.
 -> IO ()
treeModelRefNode self iter = with iter $ \iter ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_ref_node argPtr1 arg2)
{-# LINE 470 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iter

-- %hash c:f5d7 d:22a6
-- | Lets the tree unref the node. This is an optional method for models to
-- implement. To be more specific, models may ignore this call as it exists
-- primarily for performance reasons.
--
-- For more information on what this means, see 'treeModelRefNode'. Please
-- note that nodes that are deleted are not unreffed.
--
treeModelUnrefNode :: TreeModelClass self => self
 -> TreeIter -- ^ @iter@ - The 'TreeIter'.
 -> IO ()
treeModelUnrefNode self iter = with iter $ \iter ->
  (\(TreeModel arg1) arg2 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_unref_node argPtr1 arg2)
{-# LINE 486 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    iter

-- %hash c:8d25 d:a7c9
-- | Emits the 'rowChanged' signal on the model.
--
-- * This function is only necessary to implement a custom tree model. When
-- using 'Graphics.UI.Gtk.ModelView.ListStore' or
-- 'Graphics.UI.Gtk.ModelView.TreeStore', this function is called
-- automatically.
--
treeModelRowChanged :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - A 'TreePath' pointing to the changed row
 -> TreeIter -- ^ @iter@ - A valid 'TreeIter' pointing to the changed row
 -> IO ()
treeModelRowChanged self path iter =
  with iter $ \iter ->
  withTreePath path $ \path ->
  (\(TreeModel arg1) (NativeTreePath arg2) arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_row_changed argPtr1 arg2 arg3)
{-# LINE 505 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    path
    iter

-- %hash c:f809 d:57af
-- | Emits the 'rowInserted' signal on the model.
--
-- * This function is only necessary to implement a custom tree model. When
-- using 'Graphics.UI.Gtk.ModelView.ListStore' or
-- 'Graphics.UI.Gtk.ModelView.TreeStore', this function is called
-- automatically.
--
treeModelRowInserted :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - A 'TreePath' pointing to the inserted row
 -> TreeIter -- ^ @iter@ - A valid 'TreeIter' pointing to the inserted row
 -> IO ()
treeModelRowInserted self path iter =
  with iter $ \iter ->
  withTreePath path $ \path ->
  (\(TreeModel arg1) (NativeTreePath arg2) arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_row_inserted argPtr1 arg2 arg3)
{-# LINE 525 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    path
    iter

-- %hash c:e917 d:6534
-- | Emits the 'rowHasChildToggled' signal on the model. This should be
-- called by models after the child state of a node changes.
--
-- * This function is only necessary to implement a custom tree model. When
-- using 'Graphics.UI.Gtk.ModelView.ListStore' or
-- 'Graphics.UI.Gtk.ModelView.TreeStore', this function is called
-- automatically.
--
treeModelRowHasChildToggled :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - A 'TreePath' pointing to the changed row
 -> TreeIter -- ^ @iter@ - A valid 'TreeIter' pointing to the changed row
 -> IO ()
treeModelRowHasChildToggled self path iter =
  with iter $ \iter ->
  withTreePath path $ \path ->
  (\(TreeModel arg1) (NativeTreePath arg2) arg3 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_row_has_child_toggled argPtr1 arg2 arg3)
{-# LINE 546 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    path
    iter

-- %hash c:c0a2 d:7ca6
-- | Emits the 'rowDeleted' signal on the model. This should be called by
-- models after a row has been removed. The location pointed to by @path@
-- should be the location that the row previously was at. It may not be a
-- valid location anymore.
--
-- * This function is only necessary to implement a custom tree model. When
-- using 'Graphics.UI.Gtk.ModelView.ListStore' or
-- 'Graphics.UI.Gtk.ModelView.TreeStore', this function is called
-- automatically.
--
treeModelRowDeleted :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - A 'TreePath' pointing to the previous location of
             -- the deleted row.
 -> IO ()
treeModelRowDeleted self path =
  withTreePath path $ \path ->
  (\(TreeModel arg1) (NativeTreePath arg2) -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_row_deleted argPtr1 arg2)
{-# LINE 568 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
    (toTreeModel self)
    path

-- %hash c:f0f3 d:a8c5
-- | Emits the 'rowsReordered' signal on the model. This should be called by
-- models when their rows have been reordered. The length of @newOrder@ must
-- be equal to the value returned by @treeModelIterNChildren self iter@.
--
-- * This function is only necessary to implement a custom tree model. When
-- using 'Graphics.UI.Gtk.ModelView.ListStore' or
-- 'Graphics.UI.Gtk.ModelView.TreeStore', this function is called
-- automatically.
--
treeModelRowsReordered :: TreeModelClass self => self
 -> TreePath -- ^ @path@ - A 'TreePath' pointing to the tree node whose
             -- children have been reordered
 -> Maybe TreeIter -- ^ @iter@ - A valid 'TreeIter' pointing to the node whose
                   -- children have been reordered, or @Nothing@ if
                   -- @path@ is @[]@.
 -> [Int] -- ^ @newOrder@ - a list of integers giving the previous position
            -- of each node at this hierarchy level.

 -> IO ()
treeModelRowsReordered self path iter array = do
  n <- treeModelIterNChildren self iter
  let l = length array
  if n/=l then error ("treeModelRowsReordered: passed-in array is of size "
                      ++show l++" but there are "++show n++
                      " children at path "++show path) else
    withTreePath path $ \path ->
    maybeWith with iter $ \iter ->
    withArray (map fromIntegral array) $ \newOrderPtr ->
    (\(TreeModel arg1) (NativeTreePath arg2) arg3 arg4 -> withForeignPtr arg1 $ \argPtr1 ->gtk_tree_model_rows_reordered argPtr1 arg2 arg3 arg4)
{-# LINE 601 "./Graphics/UI/Gtk/ModelView/TreeModel.chs" #-}
      (toTreeModel self)
      path
      iter
      newOrderPtr

--------------------
-- Signals

-- %hash c:50c7 d:8da5
-- | This signal is emitted when a row in the model has changed.
--
rowChanged :: TreeModelClass self => Signal self (TreePath -> TreeIter -> IO ())
rowChanged = Signal (connect_BOXED_BOXED__NONE "row-changed" peekTreePath peekTreeIter)

-- %hash c:f31a d:3c6b
-- | This signal is emitted when a new row has been inserted in the model.
--
--
rowInserted :: TreeModelClass self => Signal self (TreePath -> TreeIter -> IO ())
rowInserted = Signal (connect_BOXED_BOXED__NONE "row-inserted" peekTreePath peekTreeIter)

-- %hash c:7279 d:5ef
-- | This signal is emitted when a row has gotten the first child row or lost
-- its last child row.
--
rowHasChildToggled :: TreeModelClass self => Signal self (TreePath -> TreeIter -> IO ())
rowHasChildToggled = Signal (connect_BOXED_BOXED__NONE "row-has-child-toggled" peekTreePath peekTreeIter)

-- %hash c:f669 d:367f
-- | This signal is emitted when a row has been deleted.
--
-- Note that no iterator is passed to the signal handler, since the row is
-- already deleted.
--
-- Implementations of 'TreeModel' must emit row-deleted /before/ removing the
-- node from its internal data structures. This is because models and views
-- which access and monitor this model might have references on the node which
-- need to be released in the 'rowDeleted' handler.
--
rowDeleted :: TreeModelClass self => Signal self (TreePath -> IO ())
rowDeleted = Signal (connect_BOXED__NONE "row-deleted" peekTreePath)

-- %hash c:46dd d:b2e5
-- | This signal is emitted when the children of a node in the 'TreeModel'
-- have been reordered. See 'treeModelRowsReordered' for more information
-- about the parameters that this signal carries.
--
-- Note that this signal is /not/ emitted when rows are reordered by DND,
-- since this is implemented by removing and then reinserting the row.
--
rowsReordered :: TreeModelClass self =>
                 Signal self (TreePath -> Maybe TreeIter -> [Int] -> IO ())
rowsReordered = Signal $ \after model user ->
  connect_BOXED_BOXED_PTR__NONE "rows-reordered" peekTreePath
    (maybePeek peekTreeIter) after model $ \path iter arrayPtr -> do
      n <- treeModelIterNChildren model iter
      -- hopefully the model is never buggy, otherwise this can segfault
      newOrder <- peekArray n arrayPtr
      user path iter (map fromIntegral (newOrder :: [(CInt)]))

foreign import ccall safe "gtk_tree_model_get_flags"
  gtk_tree_model_get_flags :: ((Ptr TreeModel) -> (IO CInt))

foreign import ccall safe "gtk_tree_model_get_iter_from_string"
  gtk_tree_model_get_iter_from_string :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> ((Ptr CChar) -> (IO CInt))))

foreign import ccall safe "gtk_tree_model_get_iter"
  gtk_tree_model_get_iter :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> ((Ptr NativeTreePath) -> (IO CInt))))

foreign import ccall safe "gtk_tree_model_get_iter_first"
  gtk_tree_model_get_iter_first :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO CInt)))

foreign import ccall safe "gtk_tree_model_get_path"
  gtk_tree_model_get_path :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO (Ptr NativeTreePath))))

foreign import ccall safe "gtk_tree_model_get_value"
  gtk_tree_model_get_value :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (CInt -> ((Ptr GValue) -> (IO ())))))

foreign import ccall safe "gtk_tree_model_iter_next"
  gtk_tree_model_iter_next :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO CInt)))

foreign import ccall safe "gtk_tree_model_iter_children"
  gtk_tree_model_iter_children :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> ((Ptr TreeIter) -> (IO CInt))))

foreign import ccall safe "gtk_tree_model_iter_has_child"
  gtk_tree_model_iter_has_child :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO CInt)))

foreign import ccall safe "gtk_tree_model_iter_n_children"
  gtk_tree_model_iter_n_children :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO CInt)))

foreign import ccall safe "gtk_tree_model_iter_nth_child"
  gtk_tree_model_iter_nth_child :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> ((Ptr TreeIter) -> (CInt -> (IO CInt)))))

foreign import ccall safe "gtk_tree_model_iter_parent"
  gtk_tree_model_iter_parent :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> ((Ptr TreeIter) -> (IO CInt))))

foreign import ccall safe "gtk_tree_model_foreach"
  gtk_tree_model_foreach :: ((Ptr TreeModel) -> ((FunPtr ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> ((Ptr ()) -> (IO CInt)))))) -> ((Ptr ()) -> (IO ()))))

foreign import ccall safe "gtk_tree_model_get_string_from_iter"
  gtk_tree_model_get_string_from_iter :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO (Ptr CChar))))

foreign import ccall safe "gtk_tree_model_ref_node"
  gtk_tree_model_ref_node :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO ())))

foreign import ccall safe "gtk_tree_model_unref_node"
  gtk_tree_model_unref_node :: ((Ptr TreeModel) -> ((Ptr TreeIter) -> (IO ())))

foreign import ccall safe "gtk_tree_model_row_changed"
  gtk_tree_model_row_changed :: ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> (IO ()))))

foreign import ccall safe "gtk_tree_model_row_inserted"
  gtk_tree_model_row_inserted :: ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> (IO ()))))

foreign import ccall safe "gtk_tree_model_row_has_child_toggled"
  gtk_tree_model_row_has_child_toggled :: ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> (IO ()))))

foreign import ccall safe "gtk_tree_model_row_deleted"
  gtk_tree_model_row_deleted :: ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> (IO ())))

foreign import ccall safe "gtk_tree_model_rows_reordered"
  gtk_tree_model_rows_reordered :: ((Ptr TreeModel) -> ((Ptr NativeTreePath) -> ((Ptr TreeIter) -> ((Ptr CInt) -> (IO ())))))