Trait gtk4::prelude::CellAreaExt[−][src]

pub trait CellAreaExt: 'static {

Show 42 methods    fn activate<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q, 
        cell_area: &Rectangle, 
        flags: CellRendererState, 
        edit_only: bool
    ) -> bool;

    fn add<P: IsA<CellRenderer>>(&self, renderer: &P);

    fn add_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        sibling: &Q
    );

    fn apply_attributes<P: IsA<TreeModel>>(
        &self, 
        tree_model: &P, 
        iter: &TreeIter, 
        is_expander: bool, 
        is_expanded: bool
    );

    fn attribute_connect<P: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        attribute: &str, 
        column: i32
    );

    fn attribute_disconnect<P: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        attribute: &str
    );

    fn attribute_get_column<P: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        attribute: &str
    ) -> i32;

    fn copy_context<P: IsA<CellAreaContext>>(
        &self, 
        context: &P
    ) -> Option<CellAreaContext>;

    fn create_context(&self) -> Option<CellAreaContext>;

    fn focus(&self, direction: DirectionType) -> bool;

    fn foreach<P: FnMut(&CellRenderer) -> bool>(&self, callback: P);

    fn foreach_alloc<P: IsA<CellAreaContext>, Q: IsA<Widget>, R: FnMut(&CellRenderer, &Rectangle, &Rectangle) -> bool>(
        &self, 
        context: &P, 
        widget: &Q, 
        cell_area: &Rectangle, 
        background_area: &Rectangle, 
        callback: R
    );

    fn cell_allocation<P: IsA<CellAreaContext>, Q: IsA<Widget>, R: IsA<CellRenderer>>(
        &self, 
        context: &P, 
        widget: &Q, 
        renderer: &R, 
        cell_area: &Rectangle
    ) -> Rectangle;

    fn cell_at_position<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q, 
        cell_area: &Rectangle, 
        x: i32, 
        y: i32
    ) -> (CellRenderer, Rectangle);

    fn current_path_string(&self) -> Option<GString>;

    fn edit_widget(&self) -> Option<CellEditable>;

    fn edited_cell(&self) -> Option<CellRenderer>;

    fn focus_cell(&self) -> Option<CellRenderer>;

    fn focus_from_sibling<P: IsA<CellRenderer>>(
        &self, 
        renderer: &P
    ) -> Option<CellRenderer>;

    fn focus_siblings<P: IsA<CellRenderer>>(
        &self, 
        renderer: &P
    ) -> Vec<CellRenderer>;

    fn preferred_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q
    ) -> (i32, i32);

    fn preferred_height_for_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q, 
        width: i32
    ) -> (i32, i32);

    fn preferred_width<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q
    ) -> (i32, i32);

    fn preferred_width_for_height<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q, 
        height: i32
    ) -> (i32, i32);

    fn request_mode(&self) -> SizeRequestMode;

    fn has_renderer<P: IsA<CellRenderer>>(&self, renderer: &P) -> bool;

    fn inner_cell_area<P: IsA<Widget>>(
        &self, 
        widget: &P, 
        cell_area: &Rectangle
    ) -> Rectangle;

    fn is_activatable(&self) -> bool;

    fn is_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        sibling: &Q
    ) -> bool;

    fn remove<P: IsA<CellRenderer>>(&self, renderer: &P);

    fn remove_focus_sibling<P: IsA<CellRenderer>, Q: IsA<CellRenderer>>(
        &self, 
        renderer: &P, 
        sibling: &Q
    );

    fn request_renderer<P: IsA<CellRenderer>, Q: IsA<Widget>>(
        &self, 
        renderer: &P, 
        orientation: Orientation, 
        widget: &Q, 
        for_size: i32
    ) -> (i32, i32);

    fn set_focus_cell<P: IsA<CellRenderer>>(&self, renderer: &P);

    fn snapshot<P: IsA<CellAreaContext>, Q: IsA<Widget>>(
        &self, 
        context: &P, 
        widget: &Q, 
        snapshot: &Snapshot, 
        background_area: &Rectangle, 
        cell_area: &Rectangle, 
        flags: CellRendererState, 
        paint_focus: bool
    );

    fn stop_editing(&self, canceled: bool);

    fn connect_add_editable<F: Fn(&Self, &CellRenderer, &CellEditable, &Rectangle, TreePath) + 'static>(
        &self, 
        f: F
    ) -> SignalHandlerId;

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

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

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

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

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

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

}
Expand description

Trait containing all CellArea methods.

Implementors

CellAreaBox, CellArea

Required methods

Activates self, usually by activating the currently focused cell, however some subclasses which embed widgets in the area can also activate a widget if it currently has the focus.

context

the CellAreaContext in context with the current row data

widget

the Widget that self is rendering on

cell_area

the size and location of self relative to widget’s allocation

flags

the CellRendererState flags for self for this row of data.

edit_only

if true then only cell renderers that are CellRendererMode::Editable will be activated.

Returns

Whether self was successfully activated.

Adds renderer to self with the default child cell properties.

renderer

the CellRenderer to add to self

Adds sibling to renderer’s focusable area, focus will be drawn around renderer and all of its siblings if renderer can focus for a given row.

Events handled by focus siblings can also activate the given focusable renderer.

renderer

the CellRenderer expected to have focus

sibling

the CellRenderer to add to renderer’s focus area

Applies any connected attributes to the renderers in self by pulling the values from tree_model.

tree_model

the TreeModel to pull values from

iter

the TreeIter in tree_model to apply values for

is_expander

whether iter has children

is_expanded

whether iter is expanded in the view and children are visible

Connects an attribute to apply values from column for the TreeModel in use.

renderer

the CellRenderer to connect an attribute for

attribute

the attribute name

column

the TreeModel column to fetch attribute values from

Disconnects attribute for the renderer in self so that attribute will no longer be updated with values from the model.

renderer

the CellRenderer to disconnect an attribute for

attribute

the attribute name

Returns the model column that an attribute has been mapped to, or -1 if the attribute is not mapped.

renderer

a CellRenderer

attribute

an attribute on the renderer

Returns

the model column, or -1

This is sometimes needed for cases where rows need to share alignments in one orientation but may be separately grouped in the opposing orientation.

For instance, IconView creates all icons (rows) to have the same width and the cells theirin to have the same horizontal alignments. However each row of icons may have a separate collective height. IconView uses this to request the heights of each row based on a context which was already used to request all the row widths that are to be displayed.

context

the CellAreaContext to copy

Returns

a newly created CellAreaContext copy of context.

Creates a CellAreaContext to be used with self for all purposes. CellAreaContext stores geometry information for rows for which it was operated on, it is important to use the same context for the same row of data at all times (i.e. one should render and handle events with the same CellAreaContext which was used to request the size of those rows of data).

Returns

a newly created CellAreaContext which can be used with self.

This should be called by the self’s owning layout widget when focus is to be passed to self, or moved within self for a given direction and row data.

Implementing CellArea classes should implement this method to receive and navigate focus in its own way particular to how it lays out cells.

direction

the DirectionType

Returns

true if focus remains inside self as a result of this call.

Calls callback for every CellRenderer in self.

callback

the GtkCellCallback to call

callback_data

user provided data pointer

Calls callback for every CellRenderer in self with the allocated rectangle inside cell_area.

context

the CellAreaContext for this row of data.

widget

the Widget that self is rendering to

cell_area

the widget relative coordinates and size for self

background_area

the widget relative coordinates of the background area

callback

the GtkCellAllocCallback to call

callback_data

user provided data pointer

Derives the allocation of renderer inside self if self were to be renderered in cell_area.

context

the CellAreaContext used to hold sizes for self.

widget

the Widget that self is rendering on

renderer

the CellRenderer to get the allocation for

cell_area

the whole allocated area for self in widget for this row

Returns
allocation

where to store the allocation for renderer

Gets the CellRenderer at x and y coordinates inside self and optionally returns the full cell allocation for it inside cell_area.

context

the CellAreaContext used to hold sizes for self.

widget

the Widget that self is rendering on

cell_area

the whole allocated area for self in widget for this row

x

the x position

y

the y position

Returns

the CellRenderer at x and y.

alloc_area

where to store the inner allocated area of the returned cell renderer

Gets the current TreePath string for the currently applied TreeIter, this is implicitly updated when apply_attributes() is called and can be used to interact with renderers from CellArea subclasses.

Returns

The current TreePath string for the current attributes applied to self. This string belongs to the area and should not be freed.

Gets the CellEditable widget currently used to edit the currently edited cell.

Returns

The currently active CellEditable widget

Gets the CellRenderer in self that is currently being edited.

Returns

The currently edited CellRenderer

Retrieves the currently focused cell for self

Returns

the currently focused cell in self.

Gets the CellRenderer which is expected to be focusable for which renderer is, or may be a sibling.

This is handy for CellArea subclasses when handling events, after determining the renderer at the event location it can then chose to activate the focus cell for which the event cell may have been a sibling.

renderer

the CellRenderer

Returns

the CellRenderer for which renderer is a sibling

Gets the focus sibling cell renderers for renderer.

renderer

the CellRenderer expected to have focus

Returns

A GList of CellRenderers. The returned list is internal and should not be freed.

Retrieves a cell area’s initial minimum and natural height.

self will store some geometrical information in context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the minimum_height and natural_height of this call but rather to consult CellAreaContextExt::preferred_height() after a series of requests.

context

the CellAreaContext to perform this request with

widget

the Widget where self will be rendering

Returns
minimum_height

location to store the minimum height

natural_height

location to store the natural height

Retrieves a cell area’s minimum and natural height if it would be given the specified width.

self stores some geometrical information in context along the way while calling preferred_width(). It’s important to perform a series of preferred_width() requests with context first and then call preferred_height_for_width() on each cell area individually to get the height for width of each fully requested row.

If at some point, the width of a single row changes, it should be requested with preferred_width() again and then the full width of the requested rows checked again with CellAreaContextExt::preferred_width().

context

the CellAreaContext which has already been requested for widths.

widget

the Widget where self will be rendering

width

the width for which to check the height of this area

Returns
minimum_height

location to store the minimum height

natural_height

location to store the natural height

Retrieves a cell area’s initial minimum and natural width.

self will store some geometrical information in context along the way; when requesting sizes over an arbitrary number of rows, it’s not important to check the minimum_width and natural_width of this call but rather to consult CellAreaContextExt::preferred_width() after a series of requests.

context

the CellAreaContext to perform this request with

widget

the Widget where self will be rendering

Returns
minimum_width

location to store the minimum width

natural_width

location to store the natural width

Retrieves a cell area’s minimum and natural width if it would be given the specified height.

self stores some geometrical information in context along the way while calling preferred_height(). It’s important to perform a series of preferred_height() requests with context first and then call preferred_width_for_height() on each cell area individually to get the height for width of each fully requested row.

If at some point, the height of a single row changes, it should be requested with preferred_height() again and then the full height of the requested rows checked again with CellAreaContextExt::preferred_height().

context

the CellAreaContext which has already been requested for widths.

widget

the Widget where self will be rendering

height

the height for which to check the width of this area

Returns
minimum_width

location to store the minimum width

natural_width

location to store the natural width

Gets whether the area prefers a height-for-width layout or a width-for-height layout.

Returns

The SizeRequestMode preferred by self.

Checks if self contains renderer.

renderer

the CellRenderer to check

Returns

true if renderer is in the self.

This is a convenience function for CellArea implementations to get the inner area where a given CellRenderer will be rendered. It removes any padding previously added by request_renderer().

widget

the Widget that self is rendering onto

cell_area

the widget relative coordinates where one of self’s cells is to be placed

Returns
inner_area

the return location for the inner cell area

Returns whether the area can do anything when activated, after applying new attributes to self.

Returns

whether self can do anything when activated.

Returns whether sibling is one of renderer’s focus siblings (see add_focus_sibling()).

renderer

the CellRenderer expected to have focus

sibling

the CellRenderer to check against renderer’s sibling list

Returns

true if sibling is a focus sibling of renderer

Removes renderer from self.

renderer

the CellRenderer to remove from self

Removes sibling from renderer’s focus sibling list (see add_focus_sibling()).

renderer

the CellRenderer expected to have focus

sibling

the CellRenderer to remove from renderer’s focus area

This is a convenience function for CellArea implementations to request size for cell renderers. It’s important to use this function to request size and then use inner_cell_area() at render and event time since this function will add padding around the cell for focus painting.

renderer

the CellRenderer to request size for

orientation

the Orientation in which to request size

widget

the Widget that self is rendering onto

for_size

the allocation contextual size to request for, or -1 if the base request for the orientation is to be returned.

Returns
minimum_size

location to store the minimum size

natural_size

location to store the natural size

Explicitly sets the currently focused cell to renderer.

This is generally called by implementations of GtkCellAreaClass.focus() or GtkCellAreaClass.event(), however it can also be used to implement functions such as TreeViewExt::set_cursor_on_cell().

renderer

the CellRenderer to give focus to

Snapshots self’s cells according to self’s layout onto at the given coordinates.

context

the CellAreaContext for this row of data.

widget

the Widget that self is rendering to

snapshot

the Snapshot to draw to

background_area

the widget relative coordinates for self’s background

cell_area

the widget relative coordinates for self

flags

the CellRendererState for self in this row.

paint_focus

whether self should paint focus on focused cells for focused rows or not.

Explicitly stops the editing of the currently edited cell.

If canceled is true, the currently edited cell renderer will emit the ::editing-canceled signal, otherwise the the ::editing-done signal will be emitted on the current edit widget.

See edited_cell() and edit_widget().

canceled

whether editing was canceled.

Indicates that editing has started on renderer and that editable should be added to the owning cell-layouting widget at cell_area.

renderer

the CellRenderer that started the edited

editable

the CellEditable widget to add

cell_area

the Widget relative gdk::Rectangle coordinates where editable should be added

path

the TreePath string this edit was initiated for

This signal is emitted whenever applying attributes to area from model

model

the TreeModel to apply the attributes from

iter

the TreeIter indicating which row to apply the attributes of

is_expander

whether the view shows children for this row

is_expanded

whether the view is currently showing the children of this row

Indicates that focus changed on this area. This signal is emitted either as a result of focus handling or event handling.

It’s possible that the signal is emitted even if the currently focused renderer did not change, this is because focus may change to the same renderer in the same cell area for a different row of data.

renderer

the CellRenderer that has focus

path

the current TreePath string set for area

Indicates that editing finished on renderer and that editable should be removed from the owning cell-layouting widget.

renderer

the CellRenderer that finished editeding

editable

the CellEditable widget to remove

Implementors