Trait gtk::prelude::TreeViewExt[−][src]

pub trait TreeViewExt: 'static {

Show methods    fn append_column<P: IsA<TreeViewColumn>>(&self, column: &P) -> i32;

    fn collapse_all(&self);

    fn collapse_row(&self, path: &TreePath) -> bool;

    fn columns_autosize(&self);

    fn convert_bin_window_to_tree_coords(&self, bx: i32, by: i32) -> (i32, i32);

    fn convert_bin_window_to_widget_coords(
        &self, 
        bx: i32, 
        by: i32
    ) -> (i32, i32);

    fn convert_tree_to_bin_window_coords(&self, tx: i32, ty: i32) -> (i32, i32);

    fn convert_tree_to_widget_coords(&self, tx: i32, ty: i32) -> (i32, i32);

    fn convert_widget_to_bin_window_coords(
        &self, 
        wx: i32, 
        wy: i32
    ) -> (i32, i32);

    fn convert_widget_to_tree_coords(&self, wx: i32, wy: i32) -> (i32, i32);

    fn create_row_drag_icon(&self, path: &TreePath) -> Option<Surface>;

    fn expand_all(&self);

    fn expand_row(&self, path: &TreePath, open_all: bool) -> bool;

    fn expand_to_path(&self, path: &TreePath);

    fn activates_on_single_click(&self) -> bool;

    fn background_area<P: IsA<TreeViewColumn>>(
        &self, 
        path: Option<&TreePath>, 
        column: Option<&P>
    ) -> Rectangle;

    fn bin_window(&self) -> Option<Window>;

    fn cell_area<P: IsA<TreeViewColumn>>(
        &self, 
        path: Option<&TreePath>, 
        column: Option<&P>
    ) -> Rectangle;

    fn column(&self, n: i32) -> Option<TreeViewColumn>;

    fn columns(&self) -> Vec<TreeViewColumn>;

    fn cursor(&self) -> (Option<TreePath>, Option<TreeViewColumn>);

    fn dest_row_at_pos(
        &self, 
        drag_x: i32, 
        drag_y: i32
    ) -> Option<(Option<TreePath>, TreeViewDropPosition)>;

    fn drag_dest_row(&self) -> (Option<TreePath>, TreeViewDropPosition);

    fn enables_search(&self) -> bool;

    fn enables_tree_lines(&self) -> bool;

    fn expander_column(&self) -> Option<TreeViewColumn>;

    fn is_fixed_height_mode(&self) -> bool;

    fn grid_lines(&self) -> TreeViewGridLines;

    fn is_headers_clickable(&self) -> bool;

    fn is_headers_visible(&self) -> bool;

    fn hover_expands(&self) -> bool;

    fn is_hover_selection(&self) -> bool;

    fn level_indentation(&self) -> i32;

    fn model(&self) -> Option<TreeModel>;

    fn n_columns(&self) -> u32;

    fn path_at_pos(
        &self, 
        x: i32, 
        y: i32
    ) -> Option<(Option<TreePath>, Option<TreeViewColumn>, i32, i32)>;

    fn is_reorderable(&self) -> bool;

    fn is_rubber_banding(&self) -> bool;

    fn search_column(&self) -> i32;

    fn search_entry(&self) -> Option<Entry>;

    fn selection(&self) -> TreeSelection;

    fn shows_expanders(&self) -> bool;

    fn tooltip_column(&self) -> i32;

    fn tooltip_context(
        &self, 
        x: &mut i32, 
        y: &mut i32, 
        keyboard_tip: bool
    ) -> Option<(Option<TreeModel>, TreePath, TreeIter)>;

    fn visible_range(&self) -> Option<(TreePath, TreePath)>;

    fn visible_rect(&self) -> Rectangle;

    fn insert_column<P: IsA<TreeViewColumn>>(
        &self, 
        column: &P, 
        position: i32
    ) -> i32;

    fn insert_column_with_data_func<P: IsA<CellRenderer>, Q: Fn(&TreeViewColumn, &CellRenderer, &TreeModel, &TreeIter) + 'static>(
        &self, 
        position: i32, 
        title: &str, 
        cell: &P, 
        func: Q
    ) -> i32;

    fn is_blank_at_pos(
        &self, 
        x: i32, 
        y: i32
    ) -> Option<(Option<TreePath>, Option<TreeViewColumn>, i32, i32)>;

    fn is_rubber_banding_active(&self) -> bool;

    fn map_expanded_rows<P: FnMut(&TreeView, &TreePath)>(&self, func: P);

    fn move_column_after<P: IsA<TreeViewColumn>, Q: IsA<TreeViewColumn>>(
        &self, 
        column: &P, 
        base_column: Option<&Q>
    );

    fn remove_column<P: IsA<TreeViewColumn>>(&self, column: &P) -> i32;

    fn row_activated<P: IsA<TreeViewColumn>>(&self, path: &TreePath, column: &P);

    fn row_expanded(&self, path: &TreePath) -> bool;

    fn scroll_to_cell<P: IsA<TreeViewColumn>>(
        &self, 
        path: Option<&TreePath>, 
        column: Option<&P>, 
        use_align: bool, 
        row_align: f32, 
        col_align: f32
    );

    fn scroll_to_point(&self, tree_x: i32, tree_y: i32);

    fn set_activate_on_single_click(&self, single: bool);

    fn set_column_drag_function(
        &self, 
        func: Option<Box_<dyn Fn(&TreeView, &TreeViewColumn, &TreeViewColumn, &TreeViewColumn) -> bool + 'static>>
    );

    fn set_cursor<P: IsA<TreeViewColumn>>(
        &self, 
        path: &TreePath, 
        focus_column: Option<&P>, 
        start_editing: bool
    );

    fn set_cursor_on_cell<P: IsA<TreeViewColumn>, Q: IsA<CellRenderer>>(
        &self, 
        path: &TreePath, 
        focus_column: Option<&P>, 
        focus_cell: Option<&Q>, 
        start_editing: bool
    );

    fn set_drag_dest_row(
        &self, 
        path: Option<&TreePath>, 
        pos: TreeViewDropPosition
    );

    fn set_enable_search(&self, enable_search: bool);

    fn set_enable_tree_lines(&self, enabled: bool);

    fn set_expander_column<P: IsA<TreeViewColumn>>(&self, column: Option<&P>);

    fn set_fixed_height_mode(&self, enable: bool);

    fn set_grid_lines(&self, grid_lines: TreeViewGridLines);

    fn set_headers_clickable(&self, setting: bool);

    fn set_headers_visible(&self, headers_visible: bool);

    fn set_hover_expand(&self, expand: bool);

    fn set_hover_selection(&self, hover: bool);

    fn set_level_indentation(&self, indentation: i32);

    fn set_model<P: IsA<TreeModel>>(&self, model: Option<&P>);

    fn set_reorderable(&self, reorderable: bool);

    fn set_row_separator_func(
        &self, 
        func: Option<Box_<dyn Fn(&TreeModel, &TreeIter) -> bool + 'static>>
    );

    fn set_rubber_banding(&self, enable: bool);

    fn set_search_column(&self, column: i32);

    fn set_search_entry<P: IsA<Entry>>(&self, entry: Option<&P>);

    fn set_search_equal_func<P: Fn(&TreeModel, i32, &str, &TreeIter) -> bool + 'static>(
        &self, 
        search_equal_func: P
    );

    fn set_search_position_func(
        &self, 
        func: Option<Box_<dyn Fn(&TreeView, &Widget) + 'static>>
    );

    fn set_show_expanders(&self, enabled: bool);

    fn set_tooltip_cell<P: IsA<TreeViewColumn>, Q: IsA<CellRenderer>>(
        &self, 
        tooltip: &Tooltip, 
        path: Option<&TreePath>, 
        column: Option<&P>, 
        cell: Option<&Q>
    );

    fn set_tooltip_column(&self, column: i32);

    fn set_tooltip_row(&self, tooltip: &Tooltip, path: &TreePath);

    fn unset_rows_drag_dest(&self);

    fn unset_rows_drag_source(&self);

    fn enable_grid_lines(&self) -> TreeViewGridLines;

    fn set_enable_grid_lines(&self, enable_grid_lines: TreeViewGridLines);

    fn set_ubuntu_almost_fixed_height_mode(
        &self, 
        ubuntu_almost_fixed_height_mode: bool
    );

    fn connect_columns_changed<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_cursor_changed<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_expand_collapse_cursor_row<F: Fn(&Self, bool, bool, bool) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_expand_collapse_cursor_row(
        &self, 
        object: bool, 
        p0: bool, 
        p1: bool
    ) -> bool;

    fn connect_move_cursor<F: Fn(&Self, MovementStep, i32) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_move_cursor(&self, step: MovementStep, direction: i32) -> bool;

    fn connect_row_activated<F: Fn(&Self, &TreePath, &TreeViewColumn) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_row_activated(&self, path: &TreePath, column: &TreeViewColumn);

    fn connect_row_collapsed<F: Fn(&Self, &TreeIter, &TreePath) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_row_expanded<F: Fn(&Self, &TreeIter, &TreePath) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_select_all<F: Fn(&Self) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_select_all(&self) -> bool;

    fn connect_select_cursor_parent<F: Fn(&Self) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_select_cursor_parent(&self) -> bool;

    fn connect_select_cursor_row<F: Fn(&Self, bool) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_select_cursor_row(&self, object: bool) -> bool;

    fn connect_start_interactive_search<F: Fn(&Self) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_start_interactive_search(&self) -> bool;

    fn connect_test_collapse_row<F: Fn(&Self, &TreeIter, &TreePath) -> Inhibit + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_test_expand_row<F: Fn(&Self, &TreeIter, &TreePath) -> Inhibit + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_toggle_cursor_row<F: Fn(&Self) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_toggle_cursor_row(&self) -> bool;

    fn connect_unselect_all<F: Fn(&Self) -> bool + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn emit_unselect_all(&self) -> bool;

    fn connect_activate_on_single_click_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_enable_grid_lines_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_enable_search_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_enable_tree_lines_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_expander_column_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_fixed_height_mode_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_headers_clickable_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_headers_visible_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_hover_expand_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_hover_selection_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_level_indentation_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_model_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_reorderable_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_rubber_banding_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_search_column_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_show_expanders_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_tooltip_column_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

    fn connect_ubuntu_almost_fixed_height_mode_notify<F: Fn(&Self) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

}
Expand description

Trait containing all TreeView methods.

Implementors

TreeView

Required methods

Appends column to the list of columns. If self has “fixed_height” mode enabled, then column must have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.

column

The TreeViewColumn to add.

Returns

The number of columns in self after appending.

Recursively collapses all visible, expanded nodes in self.

Collapses a row (hides its child rows, if they exist).

path

path to a row in the self

Returns

true if the row was collapsed.

Resizes all columns to their optimal width. Only works after the treeview has been realized.

Converts bin_window coordinates to coordinates for the tree (the full scrollable area of the tree).

bx

X coordinate relative to bin_window

by

Y coordinate relative to bin_window

Returns

tx

return location for tree X coordinate

ty

return location for tree Y coordinate

Converts bin_window coordinates (see bin_window()) to widget relative coordinates.

bx

bin_window X coordinate

by

bin_window Y coordinate

Returns

wx

return location for widget X coordinate

wy

return location for widget Y coordinate

Converts tree coordinates (coordinates in full scrollable area of the tree) to bin_window coordinates.

tx

tree X coordinate

ty

tree Y coordinate

Returns

bx

return location for X coordinate relative to bin_window

by

return location for Y coordinate relative to bin_window

Converts tree coordinates (coordinates in full scrollable area of the tree) to widget coordinates.

tx

X coordinate relative to the tree

ty

Y coordinate relative to the tree

Returns

wx

return location for widget X coordinate

wy

return location for widget Y coordinate

Converts widget coordinates to coordinates for the bin_window (see bin_window()).

wx

X coordinate relative to the widget

wy

Y coordinate relative to the widget

Returns

bx

return location for bin_window X coordinate

by

return location for bin_window Y coordinate

Converts widget coordinates to coordinates for the tree (the full scrollable area of the tree).

wx

X coordinate relative to the widget

wy

Y coordinate relative to the widget

Returns

tx

return location for tree X coordinate

ty

return location for tree Y coordinate

Creates a cairo::Surface representation of the row at path. This image is used for a drag icon.

path

a TreePath in self

Returns

a newly-allocated surface of the drag icon.

Recursively expands all nodes in the self.

Opens the row so its children are visible.

path

path to a row

open_all

whether to recursively expand, or just expand immediate children

Returns

true if the row existed and had children

Expands the row at path. This will also expand all parent rows of path as necessary.

path

path to a row.

Gets the setting set by set_activate_on_single_click().

Returns

true if row-activated will be emitted on a single click

Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by path and the column specified by column. If path is None, or points to a node not found in the tree, the y and height fields of the rectangle will be filled with 0. If column is None, the x and width fields will be filled with 0. The returned rectangle is equivalent to the background_area passed to CellRendererExt::render(). These background areas tile to cover the entire bin window. Contrast with the cell_area, returned by cell_area(), which returns only the cell itself, excluding surrounding borders and the tree expander area.

path

a TreePath for the row, or None to get only horizontal coordinates

column

a TreeViewColumn for the column, or None to get only vertical coordiantes

Returns

rect

rectangle to fill with cell background rect

Returns the window that self renders to. This is used primarily to compare to event->window to confirm that the event on self is on the right window.

Returns

A gdk::Window, or None when self hasn’t been realized yet.

Fills the bounding rectangle in bin_window coordinates for the cell at the row specified by path and the column specified by column. If path is None, or points to a path not currently displayed, the y and height fields of the rectangle will be filled with 0. If column is None, the x and width fields will be filled with 0. The sum of all cell rects does not cover the entire tree; there are extra pixels in between rows, for example. The returned rectangle is equivalent to the cell_area passed to CellRendererExt::render(). This function is only valid if self is realized.

path

a TreePath for the row, or None to get only horizontal coordinates

column

a TreeViewColumn for the column, or None to get only vertical coordinates

Returns

rect

rectangle to fill with cell rect

Gets the TreeViewColumn at the given position in the tree_view.

n

The position of the column, counting from 0.

Returns

The TreeViewColumn, or None if the position is outside the range of columns.

Returns a GList of all the TreeViewColumn s currently in self. The returned list must be freed with g_list_free ().

Returns

A list of TreeViewColumn s

Fills in path and focus_column with the current path and focus column. If the cursor isn’t currently set, then *path will be None. If no column currently has focus, then *focus_column will be None.

The returned TreePath must be freed with gtk_tree_path_free() when you are done with it.

Returns

path

A pointer to be filled with the current cursor path, or None

focus_column

A pointer to be filled with the current focus column, or None

Determines the destination row for a given position. drag_x and drag_y are expected to be in widget coordinates. This function is only meaningful if self is realized. Therefore this function will always return false if self is not realized or does not have a model.

drag_x

the position to determine the destination row for

drag_y

the position to determine the destination row for

Returns

whether there is a row at the given position, true if this is indeed the case.

path

Return location for the path of the highlighted row, or None.

pos

Return location for the drop position, or None

Gets information about the row that is highlighted for feedback.

Returns

path

Return location for the path of the highlighted row, or None.

pos

Return location for the drop position, or None

Returns whether or not the tree allows to start interactive searching by typing in text.

Returns

whether or not to let the user search interactively

Returns whether or not tree lines are drawn in self.

Returns

true if tree lines are drawn in self, false otherwise.

Returns the column that is the current expander column. This column has the expander arrow drawn next to it.

Returns

The expander column.

Returns whether fixed height mode is turned on for self.

Returns

true if self is in fixed height mode

Returns which grid lines are enabled in self.

Returns

a TreeViewGridLines value indicating which grid lines are enabled.

Returns whether all header columns are clickable.

Returns

true if all header columns are clickable, otherwise false

Returns true if the headers on the self are visible.

Returns

Whether the headers are visible or not.

Returns whether hover expansion mode is turned on for self.

Returns

true if self is in hover expansion mode

Returns whether hover selection mode is turned on for self.

Returns

true if self is in hover selection mode

Returns the amount, in pixels, of extra indentation for child levels in self.

Returns

the amount of extra indentation for child levels in self. A return value of 0 means that this feature is disabled.

Returns the model the TreeView is based on. Returns None if the model is unset.

Returns

A TreeModel, or None if none is currently being used.

Queries the number of columns in the given self.

Returns

The number of columns in the self

Finds the path at the point (x, y), relative to bin_window coordinates (please see bin_window()). That is, x and y are relative to an events coordinates. x and y must come from an event on the self only where event->window == gtk_tree_view_get_bin_window (). It is primarily for things like popup menus. If path is non-None, then it will be filled with the TreePath at that point. This path should be freed with gtk_tree_path_free(). If column is non-None, then it will be filled with the column at that point. cell_x and cell_y return the coordinates relative to the cell background (i.e. the background_area passed to CellRendererExt::render()). This function is only meaningful if self is realized. Therefore this function will always return false if self is not realized or does not have a model.

For converting widget coordinates (eg. the ones you get from GtkWidget::query-tooltip), please see convert_widget_to_bin_window_coords().

x

The x position to be identified (relative to bin_window).

y

The y position to be identified (relative to bin_window).

Returns

true if a row exists at that coordinate.

path

A pointer to a TreePath pointer to be filled in, or None

column

A pointer to a TreeViewColumn pointer to be filled in, or None

cell_x

A pointer where the X coordinate relative to the cell can be placed, or None

cell_y

A pointer where the Y coordinate relative to the cell can be placed, or None

Retrieves whether the user can reorder the tree via drag-and-drop. See set_reorderable().

Returns

true if the tree can be reordered.

Returns whether rubber banding is turned on for self. If the selection mode is SelectionMode::Multiple, rubber banding will allow the user to select multiple rows by dragging the mouse.

Returns

true if rubber banding in self is enabled.

Gets the column searched on by the interactive search code.

Returns

the column the interactive search code searches in.

[src]
fn search_entry(&self) -> Option<Entry>

Returns the Entry which is currently in use as interactive search entry for self. In case the built-in entry is being used, None will be returned.

Returns

the entry currently in use as search entry.

Gets the TreeSelection associated with self.

Returns

A TreeSelection object.

Returns whether or not expanders are drawn in self.

Returns

true if expanders are drawn in self, false otherwise.

Returns the column of self’s model which is being used for displaying tooltips on self’s rows.

Returns

the index of the tooltip column that is currently being used, or -1 if this is disabled.

This function is supposed to be used in a signal::Widget::query-tooltip signal handler for TreeView. The x, y and keyboard_tip values which are received in the signal handler, should be passed to this function without modification.

The return value indicates whether there is a tree view row at the given coordinates (true) or not (false) for mouse tooltips. For keyboard tooltips the row returned will be the cursor row. When true, then any of model, path and iter which have been provided will be set to point to that row and the corresponding model. x and y will always be converted to be relative to self’s bin_window if keyboard_tooltip is false.

x

the x coordinate (relative to widget coordinates)

y

the y coordinate (relative to widget coordinates)

keyboard_tip

whether this is a keyboard tooltip or not

Returns

whether or not the given tooltip context points to a row.

model

a pointer to receive a TreeModel or None

path

a pointer to receive a TreePath or None

iter

a pointer to receive a TreeIter or None

Sets start_path and end_path to be the first and last visible path. Note that there may be invisible paths in between.

The paths should be freed with gtk_tree_path_free() after use.

Returns

true, if valid paths were placed in start_path and end_path.

start_path

Return location for start of region, or None.

end_path

Return location for end of region, or None.

Fills visible_rect with the currently-visible region of the buffer, in tree coordinates. Convert to bin_window coordinates with convert_tree_to_bin_window_coords(). Tree coordinates start at 0,0 for row 0 of the tree, and cover the entire scrollable area of the tree.

Returns

visible_rect

rectangle to fill

This inserts the column into the self at position. If position is -1, then the column is inserted at the end. If self has “fixed_height” mode enabled, then column must have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.

column

The TreeViewColumn to be inserted.

position

The position to insert column in.

Returns

The number of columns in self after insertion.

Convenience function that inserts a new column into the TreeView with the given cell renderer and a GtkTreeCellDataFunc to set cell renderer attributes (normally using data from the model). See also TreeViewColumnExt::set_cell_data_func(), gtk_tree_view_column_pack_start(). If self has “fixed_height” mode enabled, then the new column will have its “sizing” property set to be GTK_TREE_VIEW_COLUMN_FIXED.

position

Position to insert, -1 for append

title

column title

cell

cell renderer for column

func

function to set attributes of cell renderer

Returns

number of columns in the tree view post-insert

Determine whether the point (x, y) in self is blank, that is no cell content nor an expander arrow is drawn at the location. If so, the location can be considered as the background. You might wish to take special action on clicks on the background, such as clearing a current selection, having a custom context menu or starting rubber banding.

The x and y coordinate that are provided must be relative to bin_window coordinates. That is, x and y must come from an event on self where event->window == gtk_tree_view_get_bin_window ().

For converting widget coordinates (eg. the ones you get from GtkWidget::query-tooltip), please see convert_widget_to_bin_window_coords().

The path, column, cell_x and cell_y arguments will be filled in likewise as for path_at_pos(). Please see path_at_pos() for more information.

x

The x position to be identified (relative to bin_window)

y

The y position to be identified (relative to bin_window)

Returns

true if the area at the given coordinates is blank, false otherwise.

path

A pointer to a TreePath pointer to be filled in, or None

column

A pointer to a TreeViewColumn pointer to be filled in, or None

cell_x

A pointer where the X coordinate relative to the cell can be placed, or None

cell_y

A pointer where the Y coordinate relative to the cell can be placed, or None

Returns whether a rubber banding operation is currently being done in self.

Returns

true if a rubber banding operation is currently being done in self.

Calls func on all expanded rows.

func

A function to be called

Moves column to be after to base_column. If base_column is None, then column is placed in the first position.

column

The TreeViewColumn to be moved.

base_column

The TreeViewColumn to be moved relative to, or None.

Removes column from self.

column

The TreeViewColumn to remove.

Returns

The number of columns in self after removing.

Activates the cell determined by path and column.

path

The TreePath to be activated.

column

The TreeViewColumn to be activated.

Returns true if the node pointed to by path is expanded in self.

path

A TreePath to test expansion state.

Returns

true if path is expanded.

Moves the alignments of self to the position specified by column and path. If column is None, then no horizontal scrolling occurs. Likewise, if path is None no vertical scrolling occurs. At a minimum, one of column or path need to be non-None. row_align determines where the row is placed, and col_align determines where column is placed. Both are expected to be between 0.0 and 1.0. 0.0 means left/top alignment, 1.0 means right/bottom alignment, 0.5 means center.

If use_align is false, then the alignment arguments are ignored, and the tree does the minimum amount of work to scroll the cell onto the screen. This means that the cell will be scrolled to the edge closest to its current position. If the cell is currently visible on the screen, nothing is done.

This function only works if the model is set, and path is a valid row on the model. If the model changes before the self is realized, the centered path will be modified to reflect this change.

path

The path of the row to move to, or None.

column

The TreeViewColumn to move horizontally to, or None.

use_align

whether to use alignment arguments, or false.

row_align

The vertical alignment of the row specified by path.

col_align

The horizontal alignment of the column specified by column.

Scrolls the tree view such that the top-left corner of the visible area is tree_x, tree_y, where tree_x and tree_y are specified in tree coordinates. The self must be realized before this function is called. If it isn’t, you probably want to be using scroll_to_cell().

If either tree_x or tree_y are -1, then that direction isn’t scrolled.

tree_x

X coordinate of new top-left pixel of visible area, or -1

tree_y

Y coordinate of new top-left pixel of visible area, or -1

Cause the signal::TreeView::row-activated signal to be emitted on a single click instead of a double click.

single

true to emit row-activated on a single click

Sets a user function for determining where a column may be dropped when dragged. This function is called on every column pair in turn at the beginning of a column drag to determine where a drop can take place. The arguments passed to func are: the self, the TreeViewColumn being dragged, the two TreeViewColumn s determining the drop spot, and user_data. If either of the TreeViewColumn arguments for the drop spot are None, then they indicate an edge. If func is set to be None, then self reverts to the default behavior of allowing all columns to be dropped everywhere.

func

A function to determine which columns are reorderable, or None.

Sets the current keyboard focus to be at path, and selects it. This is useful when you want to focus the user’s attention on a particular row. If focus_column is not None, then focus is given to the column specified by it. Additionally, if focus_column is specified, and start_editing is true, then editing should be started in the specified cell. This function is often followed by WidgetExt::grab_focus() (self) in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized.

If path is invalid for model, the current cursor (if any) will be unset and the function will return without failing.

path

A TreePath

focus_column

A TreeViewColumn, or None

start_editing

true if the specified cell should start being edited.

Sets the current keyboard focus to be at path, and selects it. This is useful when you want to focus the user’s attention on a particular row. If focus_column is not None, then focus is given to the column specified by it. If focus_column and focus_cell are not None, and focus_column contains 2 or more editable or activatable cells, then focus is given to the cell specified by focus_cell. Additionally, if focus_column is specified, and start_editing is true, then editing should be started in the specified cell. This function is often followed by WidgetExt::grab_focus() (self) in order to give keyboard focus to the widget. Please note that editing can only happen when the widget is realized.

If path is invalid for model, the current cursor (if any) will be unset and the function will return without failing.

path

A TreePath

focus_column

A TreeViewColumn, or None

focus_cell

A CellRenderer, or None

start_editing

true if the specified cell should start being edited.

Sets the row that is highlighted for feedback. If path is None, an existing highlight is removed.

path

The path of the row to highlight, or None

pos

Specifies whether to drop before, after or into the row

If enable_search is set, then the user can type in text to search through the tree interactively (this is sometimes called “typeahead find”).

Note that even if this is false, the user can still initiate a search using the “start-interactive-search” key binding.

true, if the user can search interactively

Sets whether to draw lines interconnecting the expanders in self. This does not have any visible effects for lists.

enabled

true to enable tree line drawing, false otherwise.

Sets the column to draw the expander arrow at. It must be in self. If column is None, then the expander arrow is always at the first visible column.

If you do not want expander arrow to appear in your tree, set the expander column to a hidden column.

column

None, or the column to draw the expander arrow at.

Enables or disables the fixed height mode of self. Fixed height mode speeds up TreeView by assuming that all rows have the same height. Only enable this option if all rows are the same height and all columns are of type TreeViewColumnSizing::Fixed.

enable

true to enable fixed height mode

Sets which grid lines to draw in self.

grid_lines

a TreeViewGridLines value indicating which grid lines to enable.

Allow the column title buttons to be clicked.

setting

true if the columns are clickable.

Sets the visibility state of the headers.

headers_visible

true if the headers are visible

Enables or disables the hover expansion mode of self. Hover expansion makes rows expand or collapse if the pointer moves over them.

expand

true to enable hover selection mode

Enables or disables the hover selection mode of self. Hover selection makes the selected row follow the pointer. Currently, this works only for the selection modes SelectionMode::Single and SelectionMode::Browse.

hover

true to enable hover selection mode

Sets the amount of extra indentation for child levels to use in self in addition to the default indentation. The value should be specified in pixels, a value of 0 disables this feature and in this case only the default indentation will be used. This does not have any visible effects for lists.

indentation

the amount, in pixels, of extra indentation in self.

Sets the model for a TreeView. If the self already has a model set, it will remove it before setting the new model. If model is None, then it will unset the old model.

model

The model.

This function is a convenience function to allow you to reorder models that support the GtkTreeDragSourceIface and the GtkTreeDragDestIface. Both TreeStore and ListStore support these. If reorderable is true, then the user can reorder the model by dragging and dropping rows. The developer can listen to these changes by connecting to the model’s signal::TreeModel::row-inserted and signal::TreeModel::row-deleted signals. The reordering is implemented by setting up the tree view as a drag source and destination. Therefore, drag and drop can not be used in a reorderable view for any other purpose.

This function does not give you any degree of control over the order – any reordering is allowed. If more control is needed, you should probably handle drag and drop manually.

reorderable

true, if the tree can be reordered.

Sets the row separator function, which is used to determine whether a row should be drawn as a separator. If the row separator function is None, no separators are drawn. This is the default value.

func

a GtkTreeViewRowSeparatorFunc

Enables or disables rubber banding in self. If the selection mode is SelectionMode::Multiple, rubber banding will allow the user to select multiple rows by dragging the mouse.

enable

true to enable rubber banding

Sets column as the column where the interactive search code should search in for the current model.

If the search column is set, users can use the “start-interactive-search” key binding to bring up search popup. The enable-search property controls whether simply typing text will also start an interactive search.

Note that column refers to a column of the current model. The search column is reset to -1 when the model is changed.

column

the column of the model to search in, or -1 to disable searching

[src]
fn set_search_entry<P: IsA<Entry>>(&self, entry: Option<&P>)

Sets the entry which the interactive search code will use for this self. This is useful when you want to provide a search entry in our interface at all time at a fixed position. Passing None for entry will make the interactive search code use the built-in popup entry again.

entry

the entry the interactive search code of self should use or None

Sets the compare function for the interactive search capabilities; note that somewhat like strcmp() returning 0 for equality GtkTreeViewSearchEqualFunc returns false on matches.

search_equal_func

the compare function to use during the search

search_user_data

user data to pass to search_equal_func, or None

search_destroy

Destroy notifier for search_user_data, or None

Sets the function to use when positioning the search dialog.

func

the function to use to position the search dialog, or None to use the default search position function

Sets whether to draw and enable expanders and indent child rows in self. When disabled there will be no expanders visible in trees and there will be no way to expand and collapse rows by default. Also note that hiding the expanders will disable the default indentation. You can set a custom indentation in this case using set_level_indentation(). This does not have any visible effects for lists.

enabled

true to enable expander drawing, false otherwise.

Sets the tip area of tooltip to the area path, column and cell have in common. For example if path is None and column is set, the tip area will be set to the full area covered by column. See also Tooltip::set_tip_area().

Note that if path is not specified and cell is set and part of a column containing the expander, the tooltip might not show and hide at the correct position. In such cases path must be set to the current node under the mouse cursor for this function to operate correctly.

See also set_tooltip_column() for a simpler alternative.

tooltip

a Tooltip

path

a TreePath or None

column

a TreeViewColumn or None

cell

a CellRenderer or None

If you only plan to have simple (text-only) tooltips on full rows, you can use this function to have TreeView handle these automatically for you. column should be set to the column in self’s model containing the tooltip texts, or -1 to disable this feature.

When enabled, property::Widget::has-tooltip will be set to true and self will connect a signal::Widget::query-tooltip signal handler.

Note that the signal handler sets the text with Tooltip::set_markup(), so &, <, etc have to be escaped in the text.

column

an integer, which is a valid column number for self’s model

Sets the tip area of tooltip to be the area covered by the row at path. See also set_tooltip_column() for a simpler alternative. See also Tooltip::set_tip_area().

tooltip

a Tooltip

path

a TreePath

Undoes the effect of gtk_tree_view_enable_model_drag_dest(). Calling this method sets property::TreeView::reorderable to false.

Undoes the effect of gtk_tree_view_enable_model_drag_source(). Calling this method sets property::TreeView::reorderable to false.

The number of columns of the treeview has changed.

The position of the cursor (focused cell) has changed.

The signal::TreeView::move-cursor signal is a [keybinding signal][GtkBindingSignal] which gets emitted when the user presses one of the cursor keys.

Applications should not connect to it, but may emit it with g_signal_emit_by_name() if they need to control the cursor programmatically. In contrast to set_cursor() and set_cursor_on_cell() when moving horizontally signal::TreeView::move-cursor does not reset the current selection.

step

the granularity of the move, as a MovementStep. MovementStep::LogicalPositions, MovementStep::VisualPositions, MovementStep::DisplayLines, MovementStep::Pages and MovementStep::BufferEnds are supported. MovementStep::LogicalPositions and MovementStep::VisualPositions are treated identically.

direction

the direction to move: +1 to move forwards; -1 to move backwards. The resulting movement is undefined for all other values.

Returns

true if step is supported, false otherwise.

The “row-activated” signal is emitted when the method row_activated() is called, when the user double clicks a treeview row with the “activate-on-single-click” property set to false, or when the user single clicks a row when the “activate-on-single-click” property set to true. It is also emitted when a non-editable row is selected and one of the keys: Space, Shift+Space, Return or Enter is pressed.

For selection handling refer to the [tree widget conceptual overview][TreeWidget] as well as TreeSelection.

path

the TreePath for the activated row

column

the TreeViewColumn in which the activation occurred

The given row has been collapsed (child nodes are hidden).

iter

the tree iter of the collapsed row

path

a tree path that points to the row

The given row has been expanded (child nodes are shown).

iter

the tree iter of the expanded row

path

a tree path that points to the row

The given row is about to be collapsed (hide its children nodes). Use this signal if you need to control the collapsibility of individual rows.

iter

the tree iter of the row to collapse

path

a tree path that points to the row

Returns

false to allow collapsing, true to reject

The given row is about to be expanded (show its children nodes). Use this signal if you need to control the expandability of individual rows.

iter

the tree iter of the row to expand

path

a tree path that points to the row

Returns

false to allow expansion, true to reject

Implementors