Package ch.bailu.gtk.gtk

Class TreeStore

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.gtk.TreeStore
All Implemented Interfaces:
PointerInterface
public class TreeStore extends Object
A tree-like data structure that can be used with the GtkTreeView

The `GtkTreeStore` object is a list model for use with a `GtkTreeView`
widget. It implements the `GtkTreeModel` interface, and consequently,
can use all of the methods available there. It also implements the
`GtkTreeSortable` interface so it can be sorted by the view. Finally,
it also implements the tree
[drag and drop][gtk3-GtkTreeView-drag-and-drop]
interfaces.

# GtkTreeStore as GtkBuildable

The GtkTreeStore implementation of the `GtkBuildable` interface allows
to specify the model columns with a <columns> element that may contain
multiple <column> elements, each specifying one model column. The “type”
attribute specifies the data type for the column.

An example of a UI Definition fragment for a tree store: 
 <object class="GtkTreeStore">
   <columns>
     <column type="gchararray"/>
     <column type="gchararray"/>
     <column type="gint"/>
   </columns>
 </object>

https://docs.gtk.org/gtk4/class.TreeStore.html

  • Constructor Details

    • TreeStore

      public TreeStore(PointerContainer pointer)

    • TreeStore

      public TreeStore(int n_columns, Object... _elipse)
      Creates a new tree store as with @n_columns columns each of the types passed
      in. Note that only types derived from standard GObject fundamental types
      are supported.

      As an example,

      ```
      gtk_tree_store_new (3, G_TYPE_INT, G_TYPE_STRING, GDK_TYPE_TEXTURE);
      ```

      will create a new `GtkTreeStore` with three columns, of type
      `int`, `gchararray`, and `GdkTexture` respectively.
      Parameters:
      n_columns - number of columns in the tree store
      _elipse - all `GType` types for the columns, from first to last

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • newvTreeStore

      public static TreeStore newvTreeStore(int n_columns, @Nonnull Int64 types)
      Non vararg creation function. Used primarily by language bindings.
      Parameters:
      n_columns - number of columns in the tree store
      types - an array of `GType` types for the columns, from first to last
      Returns:
      a new `GtkTreeStore`

    • append

      public void append(@Nonnull TreeIter iter, @Nullable TreeIter parent)
      Appends a new row to @tree_store. If @parent is non-%NULL, then it will append the
      new row after the last child of @parent, otherwise it will append a row to
      the top level. @iter will be changed to point to this new row. The row will
      be empty after this function is called. To fill in values, you need to call
      gtk_tree_store_set() or gtk_tree_store_set_value().
      Parameters:
      iter - An unset `GtkTreeIter` to set to the appended row
      parent - A valid `GtkTreeIter`

    • clear

      public void clear()
      Removes all rows from @tree_store

    • insert

      public void insert(@Nonnull TreeIter iter, @Nullable TreeIter parent, int position)
      Creates a new row at @position. If parent is non-%NULL, then the row will be
      made a child of @parent. Otherwise, the row will be created at the toplevel.
      If @position is -1 or is larger than the number of rows at that level, then
      the new row will be inserted to the end of the list. @iter will be changed
      to point to this new row. The row will be empty after this function is
      called. To fill in values, you need to call gtk_tree_store_set() or
      gtk_tree_store_set_value().
      Parameters:
      iter - An unset `GtkTreeIter` to set to the new row
      parent - A valid `GtkTreeIter`
      position - position to insert the new row, or -1 for last

    • insertAfter

      public void insertAfter(@Nonnull TreeIter iter, @Nullable TreeIter parent, @Nullable TreeIter sibling)
      Inserts a new row after @sibling. If @sibling is %NULL, then the row will be
      prepended to @parent ’s children. If @parent and @sibling are %NULL, then
      the row will be prepended to the toplevel. If both @sibling and @parent are
      set, then @parent must be the parent of @sibling. When @sibling is set,
      @parent is optional.

      @iter will be changed to point to this new row. The row will be empty after
      this function is called. To fill in values, you need to call
      gtk_tree_store_set() or gtk_tree_store_set_value().
      Parameters:
      iter - An unset `GtkTreeIter` to set to the new row
      parent - A valid `GtkTreeIter`
      sibling - A valid `GtkTreeIter`

    • insertBefore

      public void insertBefore(@Nonnull TreeIter iter, @Nullable TreeIter parent, @Nullable TreeIter sibling)
      Inserts a new row before @sibling. If @sibling is %NULL, then the row will
      be appended to @parent ’s children. If @parent and @sibling are %NULL, then
      the row will be appended to the toplevel. If both @sibling and @parent are
      set, then @parent must be the parent of @sibling. When @sibling is set,
      @parent is optional.

      @iter will be changed to point to this new row. The row will be empty after
      this function is called. To fill in values, you need to call
      gtk_tree_store_set() or gtk_tree_store_set_value().
      Parameters:
      iter - An unset `GtkTreeIter` to set to the new row
      parent - A valid `GtkTreeIter`
      sibling - A valid `GtkTreeIter`

    • insertWithValues

      public void insertWithValues(@Nullable TreeIter iter, @Nullable TreeIter parent, int position, Object... _elipse)
      Creates a new row at @position. @iter will be changed to point to this
      new row. If @position is -1, or larger than the number of rows on the list, then
      the new row will be appended to the list. The row will be filled with
      the values given to this function.

      Calling
      `gtk_tree_store_insert_with_values (tree_store, iter, position, ...)`
      has the same effect as calling 
      <!-- language="C" -->
 gtk_tree_store_insert (tree_store, iter, position);
 gtk_tree_store_set (tree_store, iter, ...);

      with the different that the former will only emit a row_inserted signal,
      while the latter will emit row_inserted, row_changed and if the tree store
      is sorted, rows_reordered. Since emitting the rows_reordered signal
      repeatedly can affect the performance of the program,
      gtk_tree_store_insert_with_values() should generally be preferred when
      inserting rows in a sorted tree store.
      Parameters:
      iter - An unset `GtkTreeIter` to set the new row
      parent - A valid `GtkTreeIter`
      position - position to insert the new row, or -1 to append after existing rows
      _elipse - pairs of column number and value, terminated with -1

    • isAncestor

      public boolean isAncestor(@Nonnull TreeIter iter, @Nonnull TreeIter descendant)
      Returns %TRUE if @iter is an ancestor of @descendant. That is, @iter is the
      parent (or grandparent or great-grandparent) of @descendant.
      Parameters:
      iter - A valid `GtkTreeIter`
      descendant - A valid `GtkTreeIter`
      Returns:
      %TRUE, if @iter is an ancestor of @descendant

    • iterDepth

      public int iterDepth(@Nonnull TreeIter iter)
      Returns the depth of @iter. This will be 0 for anything on the root level, 1
      for anything down a level, etc.
      Parameters:
      iter - A valid `GtkTreeIter`
      Returns:
      The depth of @iter

    • iterIsValid

      public boolean iterIsValid(@Nonnull TreeIter iter)
      Checks if the given iter is a valid iter for this `GtkTreeStore`.

      This function is slow. Only use it for debugging and/or testing
      purposes.
      Parameters:
      iter - the iterator to check
      Returns:
      %TRUE if the iter is valid, %FALSE if the iter is invalid.

    • moveAfter

      public void moveAfter(@Nonnull TreeIter iter, @Nullable TreeIter position)
      Moves @iter in @tree_store to the position after @position. @iter and
      @position should be in the same level. Note that this function only
      works with unsorted stores. If @position is %NULL, @iter will be moved
      to the start of the level.
      Parameters:
      iter - A `GtkTreeIter`.
      position - A `GtkTreeIter`.

    • moveBefore

      public void moveBefore(@Nonnull TreeIter iter, @Nullable TreeIter position)
      Moves @iter in @tree_store to the position before @position. @iter and
      @position should be in the same level. Note that this function only
      works with unsorted stores. If @position is %NULL, @iter will be
      moved to the end of the level.
      Parameters:
      iter - A `GtkTreeIter`
      position - A `GtkTreeIter`

    • prepend

      public void prepend(@Nonnull TreeIter iter, @Nullable TreeIter parent)
      Prepends a new row to @tree_store. If @parent is non-%NULL, then it will prepend
      the new row before the first child of @parent, otherwise it will prepend a row
      to the top level. @iter will be changed to point to this new row. The row
      will be empty after this function is called. To fill in values, you need to
      call gtk_tree_store_set() or gtk_tree_store_set_value().
      Parameters:
      iter - An unset `GtkTreeIter` to set to the prepended row
      parent - A valid `GtkTreeIter`

    • remove

      public boolean remove(@Nonnull TreeIter iter)
      Removes @iter from @tree_store. After being removed, @iter is set to the
      next valid row at that level, or invalidated if it previously pointed to the
      last one.
      Parameters:
      iter - A valid `GtkTreeIter`
      Returns:
      %TRUE if @iter is still valid, %FALSE if not.

    • reorder

      public void reorder(@Nullable TreeIter parent, @Nonnull Int new_order)
      Reorders the children of @parent in @tree_store to follow the order
      indicated by @new_order. Note that this function only works with
      unsorted stores.
      Parameters:
      parent - A `GtkTreeIter`
      new_order - an array of integers mapping the new position of each child to its old position before the re-ordering, i.e. @new_order`[newpos] = oldpos`.

    • set

      public void set(@Nonnull TreeIter iter, Object... _elipse)
      Sets the value of one or more cells in the row referenced by @iter.
      The variable argument list should contain integer column numbers,
      each column number followed by the value to be set.
      The list is terminated by a -1. For example, to set column 0 with type
      %G_TYPE_STRING to “Foo”, you would write
      `gtk_tree_store_set (store, iter, 0, "Foo", -1)`.

      The value will be referenced by the store if it is a %G_TYPE_OBJECT, and it
      will be copied if it is a %G_TYPE_STRING or %G_TYPE_BOXED.
      Parameters:
      iter - A valid `GtkTreeIter` for the row being modified
      _elipse - pairs of column number and value, terminated with -1

    • setColumnTypes

      public void setColumnTypes(int n_columns, @Nonnull Int64 types)
      This function is meant primarily for `GObjects` that inherit from
      `GtkTreeStore`, and should only be used when constructing a new
      `GtkTreeStore`. It will not function after a row has been added,
      or a method on the `GtkTreeModel` interface is called.
      Parameters:
      n_columns - Number of columns for the tree store
      types - An array of `GType` types, one for each column

    • setValue

      public void setValue(@Nonnull TreeIter iter, int column, @Nonnull Value value)
      Sets the data in the cell specified by @iter and @column.
      The type of @value must be convertible to the type of the
      column.
      Parameters:
      iter - A valid `GtkTreeIter` for the row being modified
      column - column number to modify
      value - new value for the cell

    • swap

      public void swap(@Nonnull TreeIter a, @Nonnull TreeIter b)
      Swaps @a and @b in the same level of @tree_store. Note that this function
      only works with unsorted stores.
      Parameters:
      a - A `GtkTreeIter`.
      b - Another `GtkTreeIter`.

    • asBuildable

      public Buildable asBuildable()
      Implements interface Buildable. Call this to get access to interface functions.
      Returns:
      Buildable

    • asTreeDragDest

      public TreeDragDest asTreeDragDest()
      Implements interface TreeDragDest. Call this to get access to interface functions.
      Returns:
      TreeDragDest

    • asTreeDragSource

      public TreeDragSource asTreeDragSource()
      Implements interface TreeDragSource. Call this to get access to interface functions.
      Returns:
      TreeDragSource

    • asTreeModel

      public TreeModel asTreeModel()
      Implements interface TreeModel. Call this to get access to interface functions.
      Returns:
      TreeModel

    • asTreeSortable

      public TreeSortable asTreeSortable()
      Implements interface TreeSortable. Call this to get access to interface functions.
      Returns:
      TreeSortable

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()