Trait components::ActorExt[][src]

pub trait ActorExt: 'static {
Show methods pub fn add_action<P>(&self, action: &P)
    where
        P: IsA<Action>
;
pub fn add_action_with_name<P>(&self, name: &str, action: &P)
    where
        P: IsA<Action>
;
pub fn add_child<P>(&self, child: &P)
    where
        P: IsA<Actor>
;
pub fn add_constraint<P>(&self, constraint: &P)
    where
        P: IsA<Constraint>
;
pub fn add_constraint_with_name<P>(&self, name: &str, constraint: &P)
    where
        P: IsA<Constraint>
;
pub fn add_effect<P>(&self, effect: &P)
    where
        P: IsA<Effect>
;
pub fn add_effect_with_name<P>(&self, name: &str, effect: &P)
    where
        P: IsA<Effect>
;
pub fn add_transition<P>(&self, name: &str, transition: &P)
    where
        P: IsA<Transition>
;
pub fn allocate(&self, box_: &ActorBox, flags: AllocationFlags);
pub fn allocate_align_fill(
        &self,
        box_: &ActorBox,
        x_align: f64,
        y_align: f64,
        x_fill: bool,
        y_fill: bool,
        flags: AllocationFlags
    );
pub fn allocate_available_size(
        &self,
        x: f32,
        y: f32,
        available_width: f32,
        available_height: f32,
        flags: AllocationFlags
    );
pub fn allocate_preferred_size(&self, flags: AllocationFlags);
pub fn apply_relative_transform_to_point<P>(
        &self,
        ancestor: Option<&P>,
        point: &Vertex
    ) -> Vertex
    where
        P: IsA<Actor>
;
pub fn apply_transform_to_point(&self, point: &Vertex) -> Vertex;
pub fn bind_model<P, Q>(&self, model: Option<&P>, create_child_func: Q)
    where
        P: IsA<ListModel>,
        Q: 'static + Fn(&Object) -> Actor
;
pub fn clear_actions(&self);
pub fn clear_constraints(&self);
pub fn clear_effects(&self);
pub fn contains<P>(&self, descendant: &P) -> bool
    where
        P: IsA<Actor>
;
pub fn continue_paint(&self);
pub fn create_pango_context(&self) -> Option<Context>;
pub fn create_pango_layout(&self, text: Option<&str>) -> Option<Layout>;
pub fn destroy(&self);
pub fn destroy_all_children(&self);
pub fn event(&self, event: &Event, capture: bool) -> bool;
pub fn get_action(&self, name: &str) -> Option<Action>;
pub fn get_actions(&self) -> Vec<Action, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
;
pub fn get_allocation_box(&self) -> ActorBox;
pub fn get_background_color(&self) -> InternalColor;
pub fn get_child_at_index(&self, index_: i32) -> Option<Actor>;
pub fn get_child_transform(&self) -> Matrix;
pub fn get_children(&self) -> Vec<Actor, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
;
pub fn get_clip(&self) -> (f32, f32, f32, f32);
pub fn get_clip_to_allocation(&self) -> bool;
pub fn get_constraint(&self, name: &str) -> Option<Constraint>;
pub fn get_constraints(&self) -> Vec<Constraint, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
;
pub fn get_content(&self) -> Option<Content>;
pub fn get_content_box(&self) -> ActorBox;
pub fn get_content_gravity(&self) -> ContentGravity;
pub fn get_content_repeat(&self) -> ContentRepeat;
pub fn get_content_scaling_filters(&self) -> (ScalingFilter, ScalingFilter);
pub fn get_default_paint_volume(&self) -> Option<PaintVolume>;
pub fn get_easing_delay(&self) -> u32;
pub fn get_easing_duration(&self) -> u32;
pub fn get_easing_mode(&self) -> AnimationMode;
pub fn get_effect(&self, name: &str) -> Option<Effect>;
pub fn get_effects(&self) -> Vec<Effect, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
;
pub fn get_first_child(&self) -> Option<Actor>;
pub fn get_fixed_position_set(&self) -> bool;
pub fn get_flags(&self) -> ActorFlags;
pub fn get_height(&self) -> f32;
pub fn get_last_child(&self) -> Option<Actor>;
pub fn get_layout_manager(&self) -> Option<LayoutManager>;
pub fn get_margin(&self) -> Margin;
pub fn get_margin_bottom(&self) -> f32;
pub fn get_margin_left(&self) -> f32;
pub fn get_margin_right(&self) -> f32;
pub fn get_margin_top(&self) -> f32;
pub fn get_n_children(&self) -> i32;
pub fn get_name(&self) -> Option<GString>;
pub fn get_next_sibling(&self) -> Option<Actor>;
pub fn get_offscreen_redirect(&self) -> OffscreenRedirect;
pub fn get_opacity(&self) -> u8;
pub fn get_paint_box(&self) -> Option<ActorBox>;
pub fn get_paint_opacity(&self) -> u8;
pub fn get_paint_visibility(&self) -> bool;
pub fn get_paint_volume(&self) -> Option<PaintVolume>;
pub fn get_pango_context(&self) -> Option<Context>;
pub fn get_parent(&self) -> Option<Actor>;
pub fn get_pivot_point(&self) -> (f32, f32);
pub fn get_pivot_point_z(&self) -> f32;
pub fn get_position(&self) -> (f32, f32);
pub fn get_preferred_height(&self, for_width: f32) -> (f32, f32);
pub fn get_preferred_size(&self) -> (f32, f32, f32, f32);
pub fn get_preferred_width(&self, for_height: f32) -> (f32, f32);
pub fn get_previous_sibling(&self) -> Option<Actor>;
pub fn get_reactive(&self) -> bool;
pub fn get_request_mode(&self) -> RequestMode;
pub fn get_rotation_angle(&self, axis: RotateAxis) -> f64;
pub fn get_scale(&self) -> (f64, f64);
pub fn get_scale_z(&self) -> f64;
pub fn get_size(&self) -> (f32, f32);
pub fn get_stage(&self) -> Option<Stage>;
pub fn get_text_direction(&self) -> TextDirection;
pub fn get_transform(&self) -> Matrix;
pub fn get_transformed_paint_volume<P>(
        &self,
        relative_to_ancestor: &P
    ) -> Option<PaintVolume>
    where
        P: IsA<Actor>
;
pub fn get_transformed_position(&self) -> (f32, f32);
pub fn get_transformed_size(&self) -> (f32, f32);
pub fn get_transition(&self, name: &str) -> Option<Transition>;
pub fn get_translation(&self) -> (f32, f32, f32);
pub fn get_width(&self) -> f32;
pub fn get_x(&self) -> f32;
pub fn get_x_align(&self) -> ActorAlign;
pub fn get_x_expand(&self) -> bool;
pub fn get_y(&self) -> f32;
pub fn get_y_align(&self) -> ActorAlign;
pub fn get_y_expand(&self) -> bool;
pub fn get_z_position(&self) -> f32;
pub fn grab_key_focus(&self);
pub fn has_actions(&self) -> bool;
pub fn has_allocation(&self) -> bool;
pub fn has_clip(&self) -> bool;
pub fn has_constraints(&self) -> bool;
pub fn has_effects(&self) -> bool;
pub fn has_key_focus(&self) -> bool;
pub fn has_overlaps(&self) -> bool;
pub fn has_pointer(&self) -> bool;
pub fn hide(&self);
pub fn insert_child_above<P, Q>(&self, child: &P, sibling: Option<&Q>)
    where
        P: IsA<Actor>,
        Q: IsA<Actor>
;
pub fn insert_child_at_index<P>(&self, child: &P, index_: i32)
    where
        P: IsA<Actor>
;
pub fn insert_child_below<P, Q>(&self, child: &P, sibling: Option<&Q>)
    where
        P: IsA<Actor>,
        Q: IsA<Actor>
;
pub fn is_in_clone_paint(&self) -> bool;
pub fn is_mapped(&self) -> bool;
pub fn is_realized(&self) -> bool;
pub fn is_rotated(&self) -> bool;
pub fn is_scaled(&self) -> bool;
pub fn is_visible(&self) -> bool;
pub fn map(&self);
pub fn move_by(&self, dx: f32, dy: f32);
pub fn needs_expand(&self, orientation: Orientation) -> bool;
pub fn paint(&self);
pub fn queue_redraw(&self);
pub fn queue_redraw_with_clip(&self, clip: Option<&RectangleInt>);
pub fn queue_relayout(&self);
pub fn remove_action<P>(&self, action: &P)
    where
        P: IsA<Action>
;
pub fn remove_action_by_name(&self, name: &str);
pub fn remove_all_children(&self);
pub fn remove_all_transitions(&self);
pub fn remove_child<P>(&self, child: &P)
    where
        P: IsA<Actor>
;
pub fn remove_clip(&self);
pub fn remove_constraint<P>(&self, constraint: &P)
    where
        P: IsA<Constraint>
;
pub fn remove_constraint_by_name(&self, name: &str);
pub fn remove_effect<P>(&self, effect: &P)
    where
        P: IsA<Effect>
;
pub fn remove_effect_by_name(&self, name: &str);
pub fn remove_transition(&self, name: &str);
pub fn replace_child<P, Q>(&self, old_child: &P, new_child: &Q)
    where
        P: IsA<Actor>,
        Q: IsA<Actor>
;
pub fn restore_easing_state(&self);
pub fn save_easing_state(&self);
pub fn set_allocation(&self, box_: &ActorBox, flags: AllocationFlags);
pub fn set_background_color(&self, color: Option<Color<f64>>);
pub fn set_child_above_sibling<P, Q>(&self, child: &P, sibling: Option<&Q>)
    where
        P: IsA<Actor>,
        Q: IsA<Actor>
;
pub fn set_child_at_index<P>(&self, child: &P, index_: i32)
    where
        P: IsA<Actor>
;
pub fn set_child_below_sibling<P, Q>(&self, child: &P, sibling: Option<&Q>)
    where
        P: IsA<Actor>,
        Q: IsA<Actor>
;
pub fn set_child_transform(&self, transform: Option<&Matrix>);
pub fn set_clip(&self, xoff: f32, yoff: f32, width: f32, height: f32);
pub fn set_clip_to_allocation(&self, clip_set: bool);
pub fn set_content<P>(&self, content: Option<&P>)
    where
        P: IsA<Content>
;
pub fn set_content_gravity(&self, gravity: ContentGravity);
pub fn set_content_repeat(&self, repeat: ContentRepeat);
pub fn set_content_scaling_filters(
        &self,
        min_filter: ScalingFilter,
        mag_filter: ScalingFilter
    );
pub fn set_easing_delay(&self, msecs: u32);
pub fn set_easing_duration(&self, msecs: u32);
pub fn set_easing_mode(&self, mode: AnimationMode);
pub fn set_fixed_position_set(&self, is_set: bool);
pub fn set_flags(&self, flags: ActorFlags);
pub fn set_height(&self, height: f32);
pub fn set_layout_manager<P>(&self, manager: Option<&P>)
    where
        P: IsA<LayoutManager>
;
pub fn set_margin(&self, margin: &Margin);
pub fn set_margin_bottom(&self, margin: f32);
pub fn set_margin_left(&self, margin: f32);
pub fn set_margin_right(&self, margin: f32);
pub fn set_margin_top(&self, margin: f32);
pub fn set_name(&self, name: &str);
pub fn set_offscreen_redirect(&self, redirect: OffscreenRedirect);
pub fn set_opacity(&self, opacity: u8);
pub fn set_pivot_point(&self, pivot_x: f32, pivot_y: f32);
pub fn set_pivot_point_z(&self, pivot_z: f32);
pub fn set_position(&self, x: f32, y: f32);
pub fn set_reactive(&self, reactive: bool);
pub fn set_request_mode(&self, mode: RequestMode);
pub fn set_rotation_angle(&self, axis: RotateAxis, angle: f64);
pub fn set_scale(&self, scale_x: f64, scale_y: f64);
pub fn set_scale_z(&self, scale_z: f64);
pub fn set_size(&self, width: f32, height: f32);
pub fn set_text_direction(&self, text_dir: TextDirection);
pub fn set_transform(&self, transform: Option<&Matrix>);
pub fn set_translation(
        &self,
        translate_x: f32,
        translate_y: f32,
        translate_z: f32
    );
pub fn set_width(&self, width: f32);
pub fn set_x(&self, x: f32);
pub fn set_x_align(&self, x_align: ActorAlign);
pub fn set_x_expand(&self, expand: bool);
pub fn set_y(&self, y: f32);
pub fn set_y_align(&self, y_align: ActorAlign);
pub fn set_y_expand(&self, expand: bool);
pub fn set_z_position(&self, z_position: f32);
pub fn should_pick_paint(&self) -> bool;
pub fn show(&self);
pub fn transform_stage_point(&self, x: f32, y: f32) -> Option<(f32, f32)>;
pub fn unmap(&self);
pub fn unset_flags(&self, flags: ActorFlags);
pub fn set_property_actions<P>(&self, actions: Option<&P>)
    where
        P: IsA<Action> + SetValueOptional
;
pub fn get_property_allocation(&self) -> Option<ActorBox>;
pub fn get_property_background_color_set(&self) -> bool;
pub fn get_property_child_transform_set(&self) -> bool;
pub fn get_property_clip_rect(&self) -> Option<InternalRect>;
pub fn set_property_clip_rect(&self, clip_rect: Option<&InternalRect>);
pub fn set_property_constraints<P>(&self, constraints: Option<&P>)
    where
        P: IsA<Constraint> + SetValueOptional
;
pub fn set_property_effect<P>(&self, effect: Option<&P>)
    where
        P: IsA<Effect> + SetValueOptional
;
pub fn get_property_fixed_x(&self) -> f32;
pub fn set_property_fixed_x(&self, fixed_x: f32);
pub fn get_property_fixed_y(&self) -> f32;
pub fn set_property_fixed_y(&self, fixed_y: f32);
pub fn get_property_has_clip(&self) -> bool;
pub fn get_property_has_pointer(&self) -> bool;
pub fn get_property_magnification_filter(&self) -> ScalingFilter;
pub fn set_property_magnification_filter(
        &self,
        magnification_filter: ScalingFilter
    );
pub fn get_property_mapped(&self) -> bool;
pub fn get_property_min_height(&self) -> f32;
pub fn set_property_min_height(&self, min_height: f32);
pub fn get_property_min_height_set(&self) -> bool;
pub fn set_property_min_height_set(&self, min_height_set: bool);
pub fn get_property_min_width(&self) -> f32;
pub fn set_property_min_width(&self, min_width: f32);
pub fn get_property_min_width_set(&self) -> bool;
pub fn set_property_min_width_set(&self, min_width_set: bool);
pub fn get_property_minification_filter(&self) -> ScalingFilter;
pub fn set_property_minification_filter(
        &self,
        minification_filter: ScalingFilter
    );
pub fn get_property_natural_height(&self) -> f32;
pub fn set_property_natural_height(&self, natural_height: f32);
pub fn get_property_natural_height_set(&self) -> bool;
pub fn set_property_natural_height_set(&self, natural_height_set: bool);
pub fn get_property_natural_width(&self) -> f32;
pub fn set_property_natural_width(&self, natural_width: f32);
pub fn get_property_natural_width_set(&self) -> bool;
pub fn set_property_natural_width_set(&self, natural_width_set: bool);
pub fn get_property_realized(&self) -> bool;
pub fn get_property_rotation_angle_x(&self) -> f64;
pub fn set_property_rotation_angle_x(&self, rotation_angle_x: f64);
pub fn get_property_rotation_angle_y(&self) -> f64;
pub fn set_property_rotation_angle_y(&self, rotation_angle_y: f64);
pub fn get_property_rotation_angle_z(&self) -> f64;
pub fn set_property_rotation_angle_z(&self, rotation_angle_z: f64);
pub fn get_property_scale_x(&self) -> f64;
pub fn set_property_scale_x(&self, scale_x: f64);
pub fn get_property_scale_y(&self) -> f64;
pub fn set_property_scale_y(&self, scale_y: f64);
pub fn get_property_show_on_set_parent(&self) -> bool;
pub fn set_property_show_on_set_parent(&self, show_on_set_parent: bool);
pub fn get_property_transform_set(&self) -> bool;
pub fn get_property_translation_x(&self) -> f32;
pub fn set_property_translation_x(&self, translation_x: f32);
pub fn get_property_translation_y(&self) -> f32;
pub fn set_property_translation_y(&self, translation_y: f32);
pub fn get_property_translation_z(&self) -> f32;
pub fn set_property_translation_z(&self, translation_z: f32);
pub fn get_property_visible(&self) -> bool;
pub fn set_property_visible(&self, visible: bool);
pub fn connect_allocation_changed<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &ActorBox, AllocationFlags)
;
pub fn connect_button_press_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &ButtonEvent) -> bool
;
pub fn connect_button_release_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &ButtonEvent) -> bool
;
pub fn connect_captured_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &Event) -> bool
;
pub fn connect_destroy<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_enter_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &CrossingEvent) -> bool
;
pub fn connect_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &Event) -> bool
;
pub fn connect_hide<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_key_focus_in<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_key_focus_out<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_key_press_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &KeyEvent) -> bool
;
pub fn connect_key_release_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &KeyEvent) -> bool
;
pub fn connect_leave_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &CrossingEvent) -> bool
;
pub fn connect_motion_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &MotionEvent) -> bool
;
pub fn connect_parent_set<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, Option<&Actor>)
;
pub fn connect_queue_redraw<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &Actor)
;
pub fn connect_queue_relayout<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_scroll_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &ScrollEvent) -> bool
;
pub fn connect_show<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_touch_event<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &Event) -> bool
;
pub fn connect_transition_stopped<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self, &str, bool)
;
pub fn connect_transitions_completed<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_actions_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_allocation_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_background_color_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_background_color_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_child_transform_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_child_transform_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_clip_rect_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_clip_to_allocation_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_constraints_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_content_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_content_box_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_content_gravity_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_content_repeat_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_effect_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_first_child_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_fixed_position_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_fixed_x_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_fixed_y_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_has_clip_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_has_pointer_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_height_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_last_child_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_layout_manager_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_magnification_filter_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_mapped_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_margin_bottom_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_margin_left_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_margin_right_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_margin_top_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_min_height_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_min_height_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_min_width_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_min_width_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_minification_filter_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_name_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_natural_height_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_natural_height_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_natural_width_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_natural_width_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_offscreen_redirect_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_opacity_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_pivot_point_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_pivot_point_z_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_position_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_reactive_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_realized_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_request_mode_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_rotation_angle_x_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_rotation_angle_y_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_rotation_angle_z_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_scale_x_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_scale_y_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_scale_z_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_show_on_set_parent_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_size_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_text_direction_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_transform_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_transform_set_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_translation_x_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_translation_y_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_translation_z_notify<F>(
        &self,
        f: F
    ) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_visible_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_width_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_x_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_x_align_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_x_expand_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_y_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_y_align_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_y_expand_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
pub fn connect_property_z_position_notify<F>(&self, f: F) -> SignalHandlerId
    where
        F: 'static + Fn(&Self)
;
}

Trait containing all Actor methods.

Implementors

Actor, Box, Clone, Group, Rectangle, ScrollActor, Text, Texture

Required methods

pub fn add_action<P>(&self, action: &P) where
    P: IsA<Action>, 
[src]

Adds action to the list of actions applied to self

A Action can only belong to one actor at a time

The Actor will hold a reference on action until either ActorExt::remove_action or ActorExt::clear_actions is called

action

a Action

pub fn add_action_with_name<P>(&self, name: &str, action: &P) where
    P: IsA<Action>, 
[src]

A convenience function for setting the name of a Action while adding it to the list of actions applied to self

This function is the logical equivalent of:

  actor_meta_set_name (ACTOR_META (action), name);
  actor_add_action (self, action);

name

the name to set on the action

action

a Action

pub fn add_child<P>(&self, child: &P) where
    P: IsA<Actor>, 
[src]

Adds child to the children of self.

This function will acquire a reference on child that will only be released when calling ActorExt::remove_child.

This function will take into consideration the Actor:depth of child, and will keep the list of children sorted.

This function will emit the Container::actor-added signal on self.

child

a Actor

pub fn add_constraint<P>(&self, constraint: &P) where
    P: IsA<Constraint>, 
[src]

Adds constraint to the list of Constraints applied to self

The Actor will hold a reference on the constraint until either ActorExt::remove_constraint or ActorExt::clear_constraints is called.

constraint

a Constraint

pub fn add_constraint_with_name<P>(&self, name: &str, constraint: &P) where
    P: IsA<Constraint>, 
[src]

A convenience function for setting the name of a Constraint while adding it to the list of constraints applied to self

This function is the logical equivalent of:

  actor_meta_set_name (ACTOR_META (constraint), name);
  actor_add_constraint (self, constraint);

name

the name to set on the constraint

constraint

a Constraint

pub fn add_effect<P>(&self, effect: &P) where
    P: IsA<Effect>, 
[src]

Adds effect to the list of Effects applied to self

The Actor will hold a reference on the effect until either ActorExt::remove_effect or ActorExt::clear_effects is called.

Note that as Effect is initially unowned, ActorExt::add_effect will sink any floating reference on effect.

effect

a Effect

pub fn add_effect_with_name<P>(&self, name: &str, effect: &P) where
    P: IsA<Effect>, 
[src]

A convenience function for setting the name of a Effect while adding it to the list of effects applied to self.

Note that as Effect is initially unowned, ActorExt::add_effect_with_name will sink any floating reference on effect.

This function is the logical equivalent of:

  actor_meta_set_name (ACTOR_META (effect), name);
  actor_add_effect (self, effect);

name

the name to set on the effect

effect

a Effect

pub fn add_transition<P>(&self, name: &str, transition: &P) where
    P: IsA<Transition>, 
[src]

Adds a transition to the Actor’s list of animations.

The name string is a per-actor unique identifier of the transition: only one Transition can be associated to the specified name.

The transition will be started once added.

This function will take a reference on the transition.

This function is usually called implicitly when modifying an animatable property.

name

the name of the transition to add

transition

the Transition to add

pub fn allocate(&self, box_: &ActorBox, flags: AllocationFlags)[src]

Assigns the size of a Actor from the given box_.

This function should only be called on the children of an actor when overriding the ActorClass.allocate() virtual function.

This function will adjust the stored allocation to take into account the alignment flags set in the Actor:x-align and Actor:y-align properties, as well as the margin values set in the Actor:margin-top, Actor:margin-right, Actor:margin-bottom, and Actor:margin-left properties.

This function will respect the easing state of the Actor and interpolate between the current allocation and the new one if the easing state duration is a positive value.

Actors can know from their allocation box whether they have moved with respect to their parent actor. The flags parameter describes additional information about the allocation, for instance whether the parent has moved with respect to the stage, for example because a grandparent’s origin has moved.

box_

new allocation of the actor, in parent-relative coordinates

flags

flags that control the allocation

pub fn allocate_align_fill(
    &self,
    box_: &ActorBox,
    x_align: f64,
    y_align: f64,
    x_fill: bool,
    y_fill: bool,
    flags: AllocationFlags
)
[src]

Allocates self by taking into consideration the available allocation area; an alignment factor on either axis; and whether the actor should fill the allocation on either axis.

The box_ should contain the available allocation width and height; if the x1 and y1 members of ActorBox are not set to 0, the allocation will be offset by their value.

This function takes into consideration the geometry request specified by the Actor:request-mode property, and the text direction.

This function is useful for fluid layout managers using legacy alignment flags. Newly written layout managers should use the Actor:x-align and Actor:y-align properties, instead, and just call ActorExt::allocate inside their ActorClass.allocate() implementation.

box_

a ActorBox, containing the available width and height

x_align

the horizontal alignment, between 0 and 1

y_align

the vertical alignment, between 0 and 1

x_fill

whether the actor should fill horizontally

y_fill

whether the actor should fill vertically

flags

allocation flags to be passed to ActorExt::allocate

pub fn allocate_available_size(
    &self,
    x: f32,
    y: f32,
    available_width: f32,
    available_height: f32,
    flags: AllocationFlags
)
[src]

Allocates self taking into account the Actor’s preferred size, but limiting it to the maximum available width and height provided.

This function will do the right thing when dealing with the actor’s request mode.

The implementation of this function is equivalent to:

  if (request_mode == REQUEST_HEIGHT_FOR_WIDTH)
    {
      actor_get_preferred_width (self, available_height,
                                         &min_width,
                                         &natural_width);
      width = CLAMP (natural_width, min_width, available_width);

      actor_get_preferred_height (self, width,
                                          &min_height,
                                          &natural_height);
      height = CLAMP (natural_height, min_height, available_height);
    }
  else if (request_mode == REQUEST_WIDTH_FOR_HEIGHT)
    {
      actor_get_preferred_height (self, available_width,
                                          &min_height,
                                          &natural_height);
      height = CLAMP (natural_height, min_height, available_height);

      actor_get_preferred_width (self, height,
                                         &min_width,
                                         &natural_width);
      width = CLAMP (natural_width, min_width, available_width);
    }
  else if (request_mode == REQUEST_CONTENT_SIZE)
    {
      content_get_preferred_size (content, &natural_width, &natural_height);

      width = CLAMP (natural_width, 0, available_width);
      height = CLAMP (natural_height, 0, available_height);
    }

  box.x1 = x; box.y1 = y;
  box.x2 = box.x1 + available_width;
  box.y2 = box.y1 + available_height;
  actor_allocate (self, &box, flags);

This function can be used by fluid layout managers to allocate an actor’s preferred size without making it bigger than the area available for the container.

x

the actor’s X coordinate

y

the actor’s Y coordinate

available_width

the maximum available width, or -1 to use the actor’s natural width

available_height

the maximum available height, or -1 to use the actor’s natural height

flags

flags controlling the allocation

pub fn allocate_preferred_size(&self, flags: AllocationFlags)[src]

Allocates the natural size of self.

This function is a utility call for Actor implementations that allocates the actor’s preferred natural size. It can be used by fixed layout managers (like Group or so called ‘composite actors’) inside the Actor::allocate implementation to give each child exactly how much space it requires, regardless of the size of the parent.

This function is not meant to be used by applications. It is also not meant to be used outside the implementation of the ActorClass.allocate virtual function.

flags

flags controlling the allocation

pub fn apply_relative_transform_to_point<P>(
    &self,
    ancestor: Option<&P>,
    point: &Vertex
) -> Vertex where
    P: IsA<Actor>, 
[src]

Transforms point in coordinates relative to the actor into ancestor-relative coordinates using the relevant transform stack (i.e. scale, rotation, etc).

If ancestor is None the ancestor will be the Stage. In this case, the coordinates returned will be the coordinates on the stage before the projection is applied. This is different from the behaviour of ActorExt::apply_transform_to_point.

ancestor

A Actor ancestor, or None to use the default Stage

point

A point as Vertex

vertex

The translated Vertex

pub fn apply_transform_to_point(&self, point: &Vertex) -> Vertex[src]

Transforms point in coordinates relative to the actor into screen-relative coordinates with the current actor transformation (i.e. scale, rotation, etc)

point

A point as Vertex

vertex

The translated Vertex

pub fn bind_model<P, Q>(&self, model: Option<&P>, create_child_func: Q) where
    P: IsA<ListModel>,
    Q: 'static + Fn(&Object) -> Actor
[src]

Binds a gio::ListModel to a Actor.

If the Actor was already bound to a gio::ListModel, the previous binding is destroyed.

The existing children of Actor are destroyed when setting a model, and new children are created and added, representing the contents of the model. The Actor is updated whenever the model changes. If model is None, the Actor is left empty.

When a Actor is bound to a model, adding and removing children directly is undefined behaviour.

model

a gio::ListModel

create_child_func

a function that creates Actor instances from the contents of the model

user_data

user data passed to create_child_func

notify

function called when unsetting the model

pub fn clear_actions(&self)[src]

Clears the list of actions applied to self

pub fn clear_constraints(&self)[src]

Clears the list of constraints applied to self

pub fn clear_effects(&self)[src]

Clears the list of effects applied to self

pub fn contains<P>(&self, descendant: &P) -> bool where
    P: IsA<Actor>, 
[src]

Determines if descendant is contained inside self (either as an immediate child, or as a deeper descendant). If self and descendant point to the same actor then it will also return true.

descendant

A Actor, possibly contained in self

Returns

whether descendent is contained within self

pub fn continue_paint(&self)[src]

Run the next stage of the paint sequence. This function should only be called within the implementation of the ‘run’ virtual of a Effect. It will cause the run method of the next effect to be applied, or it will paint the actual actor if the current effect is the last effect in the chain.

pub fn create_pango_context(&self) -> Option<Context>[src]

Creates a pango::Context for the given actor. The pango::Context is already configured using the appropriate font map, resolution and font options.

See also ActorExt::get_pango_context.

Returns

the newly created pango::Context. Use gobject::ObjectExt::unref on the returned value to deallocate its resources

pub fn create_pango_layout(&self, text: Option<&str>) -> Option<Layout>[src]

Creates a new pango::Layout from the same pango::Context used by the Actor. The pango::Layout is already configured with the font map, resolution and font options, and the given text.

If you want to keep around a pango::Layout created by this function you will have to connect to the Backend::font-changed and Backend::resolution-changed signals, and call pango::Layout::context_changed in response to them.

text

the text to set on the pango::Layout, or None

Returns

the newly created pango::Layout. Use gobject::ObjectExt::unref when done

pub fn destroy(&self)[src]

Destroys an actor. When an actor is destroyed, it will break any references it holds to other objects. If the actor is inside a container, the actor will be removed.

When you destroy a container, its children will be destroyed as well.

Note: you cannot destroy the Stage returned by Stage::get_default.

pub fn destroy_all_children(&self)[src]

Destroys all children of self.

This function releases the reference added by inserting a child actor in the list of children of self, and ensures that the Actor::destroy signal is emitted on each child of the actor.

By default, Actor will emit the Actor::destroy signal when its reference count drops to 0; the default handler of the Actor::destroy signal will destroy all the children of an actor. This function ensures that all children are destroyed, instead of just removed from self, unlike ActorExt::remove_all_children which will merely release the reference and remove each child.

Unless you acquired an additional reference on each child of self prior to calling ActorExt::remove_all_children and want to reuse the actors, you should use ActorExt::destroy_all_children in order to make sure that children are destroyed and signal handlers are disconnected even in cases where circular references prevent this from automatically happening through reference counting alone.

pub fn event(&self, event: &Event, capture: bool) -> bool[src]

This function is used to emit an event on the main stage. You should rarely need to use this function, except for synthetising events.

event

a Event

capture

true if event in in capture phase, false otherwise.

Returns

the return value from the signal emission: true if the actor handled the event, or false if the event was not handled

pub fn get_action(&self, name: &str) -> Option<Action>[src]

Retrieves the Action with the given name in the list of actions applied to self

name

the name of the action to retrieve

Returns

a Action for the given name, or None. The returned Action is owned by the actor and it should not be unreferenced directly

pub fn get_actions(&self) -> Vec<Action, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
[src]

Retrieves the list of actions applied to self

Returns

a copy of the list of Actions. The contents of the list are owned by the Actor. Use glib::List::free to free the resources allocated by the returned glib::List

pub fn get_allocation_box(&self) -> ActorBox[src]

Gets the layout box an actor has been assigned. The allocation can only be assumed valid inside a paint method; anywhere else, it may be out-of-date.

An allocation does not incorporate the actor’s scale or anchor point; those transformations do not affect layout, only rendering.

Do not call any of the actor_get_allocation_*() family of functions inside the implementation of the get_preferred_width or get_preferred_height virtual functions.

box_

the function fills this in with the actor’s allocation

pub fn get_background_color(&self) -> InternalColor[src]

Retrieves the color set using ActorExt::set_background_color.

color

return location for a Color

pub fn get_child_at_index(&self, index_: i32) -> Option<Actor>[src]

Retrieves the actor at the given index_ inside the list of children of self.

index_

the position in the list of children

Returns

a pointer to a Actor, or None

pub fn get_child_transform(&self) -> Matrix[src]

Retrieves the child transformation matrix set using ActorExt::set_child_transform; if none is currently set, the transform matrix will be initialized to the identity matrix.

transform

a Matrix

pub fn get_children(&self) -> Vec<Actor, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
[src]

Retrieves the list of children of self.

Returns

A newly allocated glib::List of Actors. Use glib::List::free when done.

pub fn get_clip(&self) -> (f32, f32, f32, f32)[src]

Gets the clip area for self, if any is set.

xoff

return location for the X offset of the clip rectangle, or None

yoff

return location for the Y offset of the clip rectangle, or None

width

return location for the width of the clip rectangle, or None

height

return location for the height of the clip rectangle, or None

pub fn get_clip_to_allocation(&self) -> bool[src]

Retrieves the value set using ActorExt::set_clip_to_allocation

Returns

true if the Actor is clipped to its allocation

pub fn get_constraint(&self, name: &str) -> Option<Constraint>[src]

Retrieves the Constraint with the given name in the list of constraints applied to self

name

the name of the constraint to retrieve

Returns

a Constraint for the given name, or None. The returned Constraint is owned by the actor and it should not be unreferenced directly

pub fn get_constraints(&self) -> Vec<Constraint, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
[src]

Retrieves the list of constraints applied to self

Returns

a copy of the list of Constraints. The contents of the list are owned by the Actor. Use glib::List::free to free the resources allocated by the returned glib::List

pub fn get_content(&self) -> Option<Content>[src]

Retrieves the contents of self.

Returns

a pointer to the Content instance, or None if none was set

pub fn get_content_box(&self) -> ActorBox[src]

Retrieves the bounding box for the Content of self.

The bounding box is relative to the actor’s allocation.

If no Content is set for self, or if self has not been allocated yet, then the result is undefined.

The content box is guaranteed to be, at most, as big as the allocation of the Actor.

If the Content used by the actor has a preferred size, then it is possible to modify the content box by using the Actor:content-gravity property.

box_

the return location for the bounding box for the Content

pub fn get_content_gravity(&self) -> ContentGravity[src]

Retrieves the content gravity as set using ActorExt::set_content_gravity.

Returns

the content gravity

pub fn get_content_repeat(&self) -> ContentRepeat[src]

Retrieves the repeat policy for a Actor set by ActorExt::set_content_repeat.

Returns

the content repeat policy

pub fn get_content_scaling_filters(&self) -> (ScalingFilter, ScalingFilter)[src]

Retrieves the values set using ActorExt::set_content_scaling_filters.

min_filter

return location for the minification filter, or None

mag_filter

return location for the magnification filter, or None

pub fn get_default_paint_volume(&self) -> Option<PaintVolume>[src]

Retrieves the default paint volume for self.

This function provides the same PaintVolume that would be computed by the default implementation inside Actor of the ActorClass.get_paint_volume() virtual function.

This function should only be used by Actor subclasses that cannot chain up to the parent implementation when computing their paint volume.

Returns

a pointer to the default PaintVolume, relative to the Actor, or None if the actor could not compute a valid paint volume. The returned value is not guaranteed to be stable across multiple frames, so if you want to retain it, you will need to copy it using PaintVolume::copy.

pub fn get_easing_delay(&self) -> u32[src]

Retrieves the delay that should be applied when tweening animatable properties.

Returns

a delay, in milliseconds

pub fn get_easing_duration(&self) -> u32[src]

Retrieves the duration of the tweening for animatable properties of self for the current easing state.

Returns

the duration of the tweening, in milliseconds

pub fn get_easing_mode(&self) -> AnimationMode[src]

Retrieves the easing mode for the tweening of animatable properties of self for the current easing state.

Returns

an easing mode

pub fn get_effect(&self, name: &str) -> Option<Effect>[src]

Retrieves the Effect with the given name in the list of effects applied to self

name

the name of the effect to retrieve

Returns

a Effect for the given name, or None. The returned Effect is owned by the actor and it should not be unreferenced directly

pub fn get_effects(&self) -> Vec<Effect, Global>

Notable traits for Vec<u8, A>

impl<A> Write for Vec<u8, A> where
    A: Allocator
[src]

Retrieves the Effects applied on self, if any

Returns

a list of Effects, or None. The elements of the returned list are owned by internals and they should not be freed. You should free the returned list using glib::List::free when done

pub fn get_first_child(&self) -> Option<Actor>[src]

Retrieves the first child of self.

The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of self while iterating it.

Returns

a pointer to a Actor, or None

pub fn get_fixed_position_set(&self) -> bool[src]

Checks whether an actor has a fixed position set (and will thus be unaffected by any layout manager).

Returns

true if the fixed position is set on the actor

pub fn get_flags(&self) -> ActorFlags[src]

Retrieves the flags set on self

Returns

a bitwise or of ActorFlags or 0

pub fn get_height(&self) -> f32[src]

Retrieves the height of a Actor.

If the actor has a valid allocation, this function will return the height of the allocated area given to the actor.

If the actor does not have a valid allocation, this function will return the actor’s natural height, that is the preferred height of the actor.

If you care whether you get the preferred height or the height that has been assigned to the actor, you should probably call a different function like ActorExt::get_allocation_box to retrieve the allocated size or ActorExt::get_preferred_height to retrieve the preferred height.

If an actor has a fixed height, for instance a height that has been assigned using ActorExt::set_height, the height returned will be the same value.

Returns

the height of the actor, in pixels

pub fn get_last_child(&self) -> Option<Actor>[src]

Retrieves the last child of self.

The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of self while iterating it.

Returns

a pointer to a Actor, or None

pub fn get_layout_manager(&self) -> Option<LayoutManager>[src]

Retrieves the LayoutManager used by self.

Returns

a pointer to the LayoutManager, or None

pub fn get_margin(&self) -> Margin[src]

Retrieves all the components of the margin of a Actor.

margin

return location for a Margin

pub fn get_margin_bottom(&self) -> f32[src]

Retrieves the bottom margin of a Actor.

Returns

the bottom margin

pub fn get_margin_left(&self) -> f32[src]

Retrieves the left margin of a Actor.

Returns

the left margin

pub fn get_margin_right(&self) -> f32[src]

Retrieves the right margin of a Actor.

Returns

the right margin

pub fn get_margin_top(&self) -> f32[src]

Retrieves the top margin of a Actor.

Returns

the top margin

pub fn get_n_children(&self) -> i32[src]

Retrieves the number of children of self.

Returns

the number of children of an actor

pub fn get_name(&self) -> Option<GString>[src]

Retrieves the name of self.

Returns

the name of the actor, or None. The returned string is owned by the actor and should not be modified or freed.

pub fn get_next_sibling(&self) -> Option<Actor>[src]

Retrieves the sibling of self that comes after it in the list of children of self’s parent.

The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of self while iterating it.

Returns

a pointer to a Actor, or None

pub fn get_offscreen_redirect(&self) -> OffscreenRedirect[src]

Retrieves whether to redirect the actor to an offscreen buffer, as set by ActorExt::set_offscreen_redirect.

Returns

the value of the offscreen-redirect property of the actor

pub fn get_opacity(&self) -> u8[src]

Retrieves the opacity value of an actor, as set by ActorExt::set_opacity.

For retrieving the absolute opacity of the actor inside a paint virtual function, see ActorExt::get_paint_opacity.

Returns

the opacity of the actor

pub fn get_paint_box(&self) -> Option<ActorBox>[src]

Retrieves the paint volume of the passed Actor, and transforms it into a 2D bounding box in stage coordinates.

This function is useful to determine the on screen area occupied by the actor. The box is only an approximation and may often be considerably larger due to the optimizations used to calculate the box. The box is never smaller though, so it can reliably be used for culling.

There are times when a 2D paint box can’t be determined, e.g. because the actor isn’t yet parented under a stage or because the actor is unable to determine a paint volume.

box_

return location for a ActorBox

Returns

true if a 2D paint box could be determined, else false.

pub fn get_paint_opacity(&self) -> u8[src]

Retrieves the absolute opacity of the actor, as it appears on the stage.

This function traverses the hierarchy chain and composites the opacity of the actor with that of its parents.

This function is intended for subclasses to use in the paint virtual function, to paint themselves with the correct opacity.

Returns

The actor opacity value.

pub fn get_paint_visibility(&self) -> bool[src]

Retrieves the ‘paint’ visibility of an actor recursively checking for non visible parents.

This is by definition the same as ACTOR_IS_MAPPED.

Returns

true if the actor is visibile and will be painted.

pub fn get_paint_volume(&self) -> Option<PaintVolume>[src]

Retrieves the paint volume of the passed Actor, or None when a paint volume can’t be determined.

The paint volume is defined as the 3D space occupied by an actor when being painted.

This function will call the ActorClass.get_paint_volume() virtual function of the Actor class. Sub-classes of Actor should not usually care about overriding the default implementation, unless they are, for instance: painting outside their allocation, or actors with a depth factor (not in terms of Actor:depth but real 3D depth).

Note: 2D actors overriding ActorClass.get_paint_volume() should ensure that their volume has a depth of 0. (This will be true as long as you don’t call PaintVolume::set_depth.)

Returns

a pointer to a PaintVolume, or None if no volume could be determined. The returned pointer is not guaranteed to be valid across multiple frames; if you want to keep it, you will need to copy it using PaintVolume::copy.

pub fn get_pango_context(&self) -> Option<Context>[src]

Retrieves the pango::Context for self. The actor’s pango::Context is already configured using the appropriate font map, resolution and font options.

Unlike ActorExt::create_pango_context, this context is owend by the Actor and it will be updated each time the options stored by the Backend change.

You can use the returned pango::Context to create a pango::Layout and render text using pango_render_layout to reuse the glyphs cache also used by internal.

Returns

the pango::Context for a Actor. The returned pango::Context is owned by the actor and should not be unreferenced by the application code

pub fn get_parent(&self) -> Option<Actor>[src]

Retrieves the parent of self.

Returns

The Actor parent, or None if no parent is set

pub fn get_pivot_point(&self) -> (f32, f32)[src]

Retrieves the coordinates of the Actor:pivot-point.

pivot_x

return location for the normalized X coordinate of the pivot point, or None

pivot_y

return location for the normalized Y coordinate of the pivot point, or None

pub fn get_pivot_point_z(&self) -> f32[src]

Retrieves the Z component of the Actor:pivot-point.

pub fn get_position(&self) -> (f32, f32)[src]

This function tries to “do what you mean” and tell you where the actor is, prior to any transformations. Retrieves the fixed position of an actor in pixels, if one has been set; otherwise, if the allocation is valid, returns the actor’s allocated position; otherwise, returns 0,0.

The returned position is in pixels.

x

return location for the X coordinate, or None

y

return location for the Y coordinate, or None

pub fn get_preferred_height(&self, for_width: f32) -> (f32, f32)[src]

Computes the requested minimum and natural heights for an actor, or if they are already computed, returns the cached values.

An actor may not get its request - depending on the layout manager that’s in effect.

A request should not incorporate the actor’s scale or anchor point; those transformations do not affect layout, only rendering.

for_width

available width to assume in computing desired height, or a negative value to indicate that no width is defined

min_height_p

return location for minimum height, or None

natural_height_p

return location for natural height, or None

pub fn get_preferred_size(&self) -> (f32, f32, f32, f32)[src]

Computes the preferred minimum and natural size of an actor, taking into account the actor’s geometry management (either height-for-width or width-for-height).

The width and height used to compute the preferred height and preferred width are the actor’s natural ones.

If you need to control the height for the preferred width, or the width for the preferred height, you should use ActorExt::get_preferred_width and ActorExt::get_preferred_height, and check the actor’s preferred geometry management using the Actor:request-mode property.

min_width_p

return location for the minimum width, or None

min_height_p

return location for the minimum height, or None

natural_width_p

return location for the natural width, or None

natural_height_p

return location for the natural height, or None

pub fn get_preferred_width(&self, for_height: f32) -> (f32, f32)[src]

Computes the requested minimum and natural widths for an actor, optionally depending on the specified height, or if they are already computed, returns the cached values.

An actor may not get its request - depending on the layout manager that’s in effect.

A request should not incorporate the actor’s scale or anchor point; those transformations do not affect layout, only rendering.

for_height

available height when computing the preferred width, or a negative value to indicate that no height is defined

min_width_p

return location for minimum width, or None

natural_width_p

return location for the natural width, or None

pub fn get_previous_sibling(&self) -> Option<Actor>[src]

Retrieves the sibling of self that comes before it in the list of children of self’s parent.

The returned pointer is only valid until the scene graph changes; it is not safe to modify the list of children of self while iterating it.

Returns

a pointer to a Actor, or None

pub fn get_reactive(&self) -> bool[src]

Checks whether self is marked as reactive.

Returns

true if the actor is reactive

pub fn get_request_mode(&self) -> RequestMode[src]

Retrieves the geometry request mode of self

Returns

the request mode for the actor

pub fn get_rotation_angle(&self, axis: RotateAxis) -> f64[src]

Retrieves the angle of rotation set by ActorExt::set_rotation_angle.

axis

the axis of the rotation

Returns

the angle of rotation, in degrees

pub fn get_scale(&self) -> (f64, f64)[src]

Retrieves an actors scale factors.

scale_x

Location to store horizonal scale factor, or None.

scale_y

Location to store vertical scale factor, or None.

pub fn get_scale_z(&self) -> f64[src]

Retrieves the scaling factor along the Z axis, as set using ActorExt::set_scale_z.

Returns

the scaling factor along the Z axis

pub fn get_size(&self) -> (f32, f32)[src]

This function tries to “do what you mean” and return the size an actor will have. If the actor has a valid allocation, the allocation will be returned; otherwise, the actors natural size request will be returned.

If you care whether you get the request vs. the allocation, you should probably call a different function like ActorExt::get_allocation_box or ActorExt::get_preferred_width.

width

return location for the width, or None.

height

return location for the height, or None.

pub fn get_stage(&self) -> Option<Stage>[src]

Retrieves the Stage where self is contained.

Returns

the stage containing the actor, or None

pub fn get_text_direction(&self) -> TextDirection[src]

Retrieves the value set using ActorExt::set_text_direction

If no text direction has been previously set, the default text direction, as returned by get_default_text_direction, will be returned instead

Returns

the TextDirection for the actor

pub fn get_transform(&self) -> Matrix[src]

Retrieves the current transformation matrix of a Actor.

transform

a Matrix

pub fn get_transformed_paint_volume<P>(
    &self,
    relative_to_ancestor: &P
) -> Option<PaintVolume> where
    P: IsA<Actor>, 
[src]

Retrieves the 3D paint volume of an actor like ActorExt::get_paint_volume does (Please refer to the documentation of ActorExt::get_paint_volume for more details.) and it additionally transforms the paint volume into the coordinate space of relative_to_ancestor. (Or the stage if None is passed for relative_to_ancestor)

This can be used by containers that base their paint volume on the volume of their children. Such containers can query the transformed paint volume of all of its children and union them together using PaintVolume::union.

relative_to_ancestor

A Actor that is an ancestor of self (or None for the stage)

Returns

a pointer to a PaintVolume, or None if no volume could be determined. The returned pointer is not guaranteed to be valid across multiple frames; if you wish to keep it, you will have to copy it using PaintVolume::copy.

pub fn get_transformed_position(&self) -> (f32, f32)[src]

Gets the absolute position of an actor, in pixels relative to the stage.

x

return location for the X coordinate, or None

y

return location for the Y coordinate, or None

pub fn get_transformed_size(&self) -> (f32, f32)[src]

Gets the absolute size of an actor in pixels, taking into account the scaling factors.

If the actor has a valid allocation, the allocated size will be used. If the actor has not a valid allocation then the preferred size will be transformed and returned.

If you want the transformed allocation, see ActorExt::get_abs_allocation_vertices instead.

When the actor (or one of its ancestors) is rotated around the X or Y axis, it no longer appears as on the stage as a rectangle, but as a generic quadrangle; in that case this function returns the size of the smallest rectangle that encapsulates the entire quad. Please note that in this case no assumptions can be made about the relative position of this envelope to the absolute position of the actor, as returned by ActorExt::get_transformed_position; if you need this information, you need to use ActorExt::get_abs_allocation_vertices to get the coords of the actual quadrangle.

width

return location for the width, or None

height

return location for the height, or None

pub fn get_transition(&self, name: &str) -> Option<Transition>[src]

Retrieves the Transition of a Actor by using the transition name.

Transitions created for animatable properties use the name of the property itself, for instance the code below:

  actor_set_easing_duration (actor, 1000);
  actor_set_rotation (actor, Y_AXIS, 360.0, x, y, z);

  transition = actor_get_transition (actor, "rotation-angle-y");
  g_signal_connect (transition, "stopped",
                    G_CALLBACK (on_transition_stopped),
                    actor);

will call the on_transition_stopped callback when the transition is finished.

If you just want to get notifications of the completion of a transition, you should use the Actor::transition-stopped signal, using the transition name as the signal detail.

name

the name of the transition

Returns

a Transition, or None is none was found to match the passed name; the returned instance is owned by internal and it should not be freed

pub fn get_translation(&self) -> (f32, f32, f32)[src]

Retrieves the translation set using ActorExt::set_translation.

translate_x

return location for the X component of the translation, or None

translate_y

return location for the Y component of the translation, or None

translate_z

return location for the Z component of the translation, or None

pub fn get_width(&self) -> f32[src]

Retrieves the width of a Actor.

If the actor has a valid allocation, this function will return the width of the allocated area given to the actor.

If the actor does not have a valid allocation, this function will return the actor’s natural width, that is the preferred width of the actor.

If you care whether you get the preferred width or the width that has been assigned to the actor, you should probably call a different function like ActorExt::get_allocation_box to retrieve the allocated size or ActorExt::get_preferred_width to retrieve the preferred width.

If an actor has a fixed width, for instance a width that has been assigned using ActorExt::set_width, the width returned will be the same value.

Returns

the width of the actor, in pixels

pub fn get_x(&self) -> f32[src]

Retrieves the X coordinate of a Actor.

This function tries to “do what you mean”, by returning the correct value depending on the actor’s state.

If the actor has a valid allocation, this function will return the X coordinate of the origin of the allocation box.

If the actor has any fixed coordinate set using ActorExt::set_x, ActorExt::set_position or Actor::set_geometry, this function will return that coordinate.

If both the allocation and a fixed position are missing, this function will return 0.

Returns

the X coordinate, in pixels, ignoring any transformation (i.e. scaling, rotation)

pub fn get_x_align(&self) -> ActorAlign[src]

Retrieves the horizontal alignment policy set using ActorExt::set_x_align.

Returns

the horizontal alignment policy.

pub fn get_x_expand(&self) -> bool[src]

Retrieves the value set with ActorExt::set_x_expand.

See also: ActorExt::needs_expand

Returns

true if the actor has been set to expand

pub fn get_y(&self) -> f32[src]

Retrieves the Y coordinate of a Actor.

This function tries to “do what you mean”, by returning the correct value depending on the actor’s state.

If the actor has a valid allocation, this function will return the Y coordinate of the origin of the allocation box.

If the actor has any fixed coordinate set using ActorExt::set_y, ActorExt::set_position or Actor::set_geometry, this function will return that coordinate.

If both the allocation and a fixed position are missing, this function will return 0.

Returns

the Y coordinate, in pixels, ignoring any transformation (i.e. scaling, rotation)

pub fn get_y_align(&self) -> ActorAlign[src]

Retrieves the vertical alignment policy set using ActorExt::set_y_align.

Returns

the vertical alignment policy.

pub fn get_y_expand(&self) -> bool[src]

Retrieves the value set with ActorExt::set_y_expand.

See also: ActorExt::needs_expand

Returns

true if the actor has been set to expand

pub fn get_z_position(&self) -> f32[src]

Retrieves the actor’s position on the Z axis.

Returns

the position on the Z axis.

pub fn grab_key_focus(&self)[src]

Sets the key focus of the Stage including self to this Actor.

pub fn has_actions(&self) -> bool[src]

Returns whether the actor has any actions applied.

Returns

true if the actor has any actions, false otherwise

pub fn has_allocation(&self) -> bool[src]

Checks if the actor has an up-to-date allocation assigned to it. This means that the actor should have an allocation: it’s visible and has a parent. It also means that there is no outstanding relayout request in progress for the actor or its children (There might be other outstanding layout requests in progress that will cause the actor to get a new allocation when the stage is laid out, however).

If this function returns false, then the actor will normally be allocated before it is next drawn on the screen.

Returns

true if the actor has an up-to-date allocation

pub fn has_clip(&self) -> bool[src]

Determines whether the actor has a clip area set or not.

Returns

true if the actor has a clip area set.

pub fn has_constraints(&self) -> bool[src]

Returns whether the actor has any constraints applied.

Returns

true if the actor has any constraints, false otherwise

pub fn has_effects(&self) -> bool[src]

Returns whether the actor has any effects applied.

Returns

true if the actor has any effects, false otherwise

pub fn has_key_focus(&self) -> bool[src]

Checks whether self is the Actor that has key focus

Returns

true if the actor has key focus, and false otherwise

pub fn has_overlaps(&self) -> bool[src]

Asks the actor’s implementation whether it may contain overlapping primitives.

For example; it may use this to determine whether the painting should be redirected to an offscreen buffer to correctly implement the opacity property.

Custom actors can override the default response by implementing the ActorClass.has_overlaps() virtual function. See ActorExt::set_offscreen_redirect for more information.

Returns

true if the actor may have overlapping primitives, and false otherwise

pub fn has_pointer(&self) -> bool[src]

Checks whether an actor contains the pointer of a InputDevice

Returns

true if the actor contains the pointer, and false otherwise

pub fn hide(&self)[src]

Flags an actor to be hidden. A hidden actor will not be rendered on the stage.

Actors are visible by default.

If this function is called on an actor without a parent, the Actor:show-on-set-parent property will be set to false as a side-effect.

pub fn insert_child_above<P, Q>(&self, child: &P, sibling: Option<&Q>) where
    P: IsA<Actor>,
    Q: IsA<Actor>, 
[src]

Inserts child into the list of children of self, above another child of self or, if sibling is None, above all the children of self.

This function will acquire a reference on child that will only be released when calling ActorExt::remove_child.

This function will not take into consideration the Actor:depth of child.

This function will emit the Container::actor-added signal on self.

child

a Actor

sibling

a child of self, or None

pub fn insert_child_at_index<P>(&self, child: &P, index_: i32) where
    P: IsA<Actor>, 
[src]

Inserts child into the list of children of self, using the given index_. If index_ is greater than the number of children in self, or is less than 0, then the new child is added at the end.

This function will acquire a reference on child that will only be released when calling ActorExt::remove_child.

This function will not take into consideration the Actor:depth of child.

This function will emit the Container::actor-added signal on self.

child

a Actor

index_

the index

pub fn insert_child_below<P, Q>(&self, child: &P, sibling: Option<&Q>) where
    P: IsA<Actor>,
    Q: IsA<Actor>, 
[src]

Inserts child into the list of children of self, below another child of self or, if sibling is None, below all the children of self.

This function will acquire a reference on child that will only be released when calling ActorExt::remove_child.

This function will not take into consideration the Actor:depth of child.

This function will emit the Container::actor-added signal on self.

child

a Actor

sibling

a child of self, or None

pub fn is_in_clone_paint(&self) -> bool[src]

Checks whether self is being currently painted by a Clone

This function is useful only inside the ::paint virtual function implementations or within handlers for the Actor::paint signal

This function should not be used by applications

Returns

true if the Actor is currently being painted by a Clone, and false otherwise

pub fn is_mapped(&self) -> bool[src]

Checks whether a Actor has been set as mapped.

See also ACTOR_IS_MAPPED and Actor:mapped

Returns

true if the actor is mapped

pub fn is_realized(&self) -> bool[src]

Checks whether a Actor is realized.

See also ACTOR_IS_REALIZED and Actor:realized.

Returns

true if the actor is realized

pub fn is_rotated(&self) -> bool[src]

Checks whether any rotation is applied to the actor.

Returns

true if the actor is rotated.

pub fn is_scaled(&self) -> bool[src]

Checks whether the actor is scaled in either dimension.

Returns

true if the actor is scaled.

pub fn is_visible(&self) -> bool[src]

Checks whether an actor is marked as visible.

See also ACTOR_IS_VISIBLE and Actor:visible.

Returns

true if the actor visible

pub fn map(&self)[src]

Sets the ActorFlags::Mapped flag on the actor and possibly maps and realizes its children if they are visible. Does nothing if the actor is not visible.

Calling this function is strongly disencouraged: the default implementation of ActorClass.map() will map all the children of an actor when mapping its parent.

When overriding map, it is mandatory to chain up to the parent implementation.

pub fn move_by(&self, dx: f32, dy: f32)[src]

Moves an actor by the specified distance relative to its current position in pixels.

This function modifies the fixed position of an actor and thus removes it from any layout management. Another way to move an actor is with an anchor point, see Actor::set_anchor_point, or with an additional translation, using ActorExt::set_translation.

dx

Distance to move Actor on X axis.

dy

Distance to move Actor on Y axis.

pub fn needs_expand(&self, orientation: Orientation) -> bool[src]

Checks whether an actor, or any of its children, is set to expand horizontally or vertically.

This function should only be called by layout managers that can assign extra space to their children.

If you want to know whether the actor was explicitly set to expand, use ActorExt::get_x_expand or ActorExt::get_y_expand.

orientation

the direction of expansion

Returns

true if the actor should expand

pub fn paint(&self)[src]

Renders the actor to display.

This function should not be called directly by applications. Call ActorExt::queue_redraw to queue paints, instead.

This function is context-aware, and will either cause a regular paint or a pick paint.

This function will emit the Actor::paint signal or the Actor::pick signal, depending on the context.

This function does not paint the actor if the actor is set to 0, unless it is performing a pick paint.

pub fn queue_redraw(&self)[src]

Queues up a redraw of an actor and any children. The redraw occurs once the main loop becomes idle (after the current batch of events has been processed, roughly).

Applications rarely need to call this, as redraws are handled automatically by modification functions.

This function will not do anything if self is not visible, or if the actor is inside an invisible part of the scenegraph.

Also be aware that painting is a NOP for actors with an opacity of 0

When you are implementing a custom actor you must queue a redraw whenever some private state changes that will affect painting or picking of your actor.

pub fn queue_redraw_with_clip(&self, clip: Option<&RectangleInt>)[src]

Queues a redraw on self limited to a specific, actor-relative rectangular area.

If clip is None this function is equivalent to ActorExt::queue_redraw.

clip

a rectangular clip region, or None

pub fn queue_relayout(&self)[src]

Indicates that the actor’s size request or other layout-affecting properties may have changed. This function is used inside Actor subclass implementations, not by applications directly.

Queueing a new layout automatically queues a redraw as well.

pub fn remove_action<P>(&self, action: &P) where
    P: IsA<Action>, 
[src]

Removes action from the list of actions applied to self

The reference held by self on the Action will be released

action

a Action

pub fn remove_action_by_name(&self, name: &str)[src]

Removes the Action with the given name from the list of actions applied to self

name

the name of the action to remove

pub fn remove_all_children(&self)[src]

Removes all children of self.

This function releases the reference added by inserting a child actor in the list of children of self.

If the reference count of a child drops to zero, the child will be destroyed. If you want to ensure the destruction of all the children of self, use ActorExt::destroy_all_children.

pub fn remove_all_transitions(&self)[src]

Removes all transitions associated to self.

pub fn remove_child<P>(&self, child: &P) where
    P: IsA<Actor>, 
[src]

Removes child from the children of self.

This function will release the reference added by ActorExt::add_child, so if you want to keep using child you will have to acquire a referenced on it before calling this function.

This function will emit the Container::actor-removed signal on self.

child

a Actor

pub fn remove_clip(&self)[src]

Removes clip area from self.

pub fn remove_constraint<P>(&self, constraint: &P) where
    P: IsA<Constraint>, 
[src]

Removes constraint from the list of constraints applied to self

The reference held by self on the Constraint will be released

constraint

a Constraint

pub fn remove_constraint_by_name(&self, name: &str)[src]

Removes the Constraint with the given name from the list of constraints applied to self

name

the name of the constraint to remove

pub fn remove_effect<P>(&self, effect: &P) where
    P: IsA<Effect>, 
[src]

Removes effect from the list of effects applied to self

The reference held by self on the Effect will be released

effect

a Effect

pub fn remove_effect_by_name(&self, name: &str)[src]

Removes the Effect with the given name from the list of effects applied to self

name

the name of the effect to remove

pub fn remove_transition(&self, name: &str)[src]

Removes the transition stored inside a Actor using name identifier.

If the transition is currently in progress, it will be stopped.

This function releases the reference acquired when the transition was added to the Actor.

name

the name of the transition to remove

pub fn replace_child<P, Q>(&self, old_child: &P, new_child: &Q) where
    P: IsA<Actor>,
    Q: IsA<Actor>, 
[src]

Replaces old_child with new_child in the list of children of self.

old_child

the child of self to replace

new_child

the Actor to replace old_child

pub fn restore_easing_state(&self)[src]

Restores the easing state as it was prior to a call to ActorExt::save_easing_state.

pub fn save_easing_state(&self)[src]

Saves the current easing state for animatable properties, and creates a new state with the default values for easing mode and duration.

New transitions created after calling this function will inherit the duration, easing mode, and delay of the new easing state; this also applies to transitions modified in flight.

pub fn set_allocation(&self, box_: &ActorBox, flags: AllocationFlags)[src]

Stores the allocation of self as defined by box_.

This function can only be called from within the implementation of the ActorClass.allocate() virtual function.

The allocation should have been adjusted to take into account constraints, alignment, and margin properties. If you are implementing a Actor subclass that provides its own layout management policy for its children instead of using a LayoutManager delegate, you should not call this function on the children of self; instead, you should call ActorExt::allocate, which will adjust the allocation box for you.

This function should only be used by subclasses of Actor that wish to store their allocation but cannot chain up to the parent’s implementation; the default implementation of the ActorClass.allocate() virtual function will call this function.

It is important to note that, while chaining up was the recommended behaviour for Actor subclasses prior to the introduction of this function, it is recommended to call ActorExt::set_allocation instead.

If the Actor is using a LayoutManager delegate object to handle the allocation of its children, this function will call the LayoutManagerExt::allocate function only if the AllocationFlags::DelegateLayout flag is set on flags, otherwise it is expected that the subclass will call LayoutManagerExt::allocate by itself. For instance, the following code:

static void
my_actor_allocate (Actor *actor,
                   const ActorBox *allocation,
                   AllocationFlags flags)
{
  ActorBox new_alloc;
  AllocationFlags new_flags;

  adjust_allocation (allocation, &new_alloc);

  new_flags = flags | DELEGATE_LAYOUT;

  // this will use the layout manager set on the actor
  actor_set_allocation (actor, &new_alloc, new_flags);
}

is equivalent to this:

static void
my_actor_allocate (Actor *actor,
                   const ActorBox *allocation,
                   AllocationFlags flags)
{
  LayoutManager *layout;
  ActorBox new_alloc;

  adjust_allocation (allocation, &new_alloc);

  actor_set_allocation (actor, &new_alloc, flags);

  layout = actor_get_layout_manager (actor);
  layout_manager_allocate (layout,
                                   CONTAINER (actor),
                                   &new_alloc,
                                   flags);
}

box_

a ActorBox

flags

allocation flags

pub fn set_background_color(&self, color: Option<Color<f64>>)[src]

Sets the background color of a Actor.

The background color will be used to cover the whole allocation of the actor. The default background color of an actor is transparent.

To check whether an actor has a background color, you can use the Actor:background-color-set actor property.

The Actor:background-color property is animatable.

color

a Color, or None to unset a previously set color

pub fn set_child_above_sibling<P, Q>(&self, child: &P, sibling: Option<&Q>) where
    P: IsA<Actor>,
    Q: IsA<Actor>, 
[src]

Sets child to be above sibling in the list of children of self.

If sibling is None, child will be the new last child of self.

This function is logically equivalent to removing child and using ActorExt::insert_child_above, but it will not emit signals or change state on child.

child

a Actor child of self

sibling

a Actor child of self, or None

pub fn set_child_at_index<P>(&self, child: &P, index_: i32) where
    P: IsA<Actor>, 
[src]

Changes the index of child in the list of children of self.

This function is logically equivalent to removing child and calling ActorExt::insert_child_at_index, but it will not emit signals or change state on child.

child

a Actor child of self

index_

the new index for child

pub fn set_child_below_sibling<P, Q>(&self, child: &P, sibling: Option<&Q>) where
    P: IsA<Actor>,
    Q: IsA<Actor>, 
[src]

Sets child to be below sibling in the list of children of self.

If sibling is None, child will be the new first child of self.

This function is logically equivalent to removing self and using ActorExt::insert_child_below, but it will not emit signals or change state on child.

child

a Actor child of self

sibling

a Actor child of self, or None

pub fn set_child_transform(&self, transform: Option<&Matrix>)[src]

Sets the transformation matrix to be applied to all the children of self prior to their own transformations. The default child transformation is the identity matrix.

If transform is None, the child transform will be unset.

The Actor:child-transform property is animatable.

transform

a Matrix, or None

pub fn set_clip(&self, xoff: f32, yoff: f32, width: f32, height: f32)[src]

Sets clip area for self. The clip area is always computed from the upper left corner of the actor, even if the anchor point is set otherwise.

xoff

X offset of the clip rectangle

yoff

Y offset of the clip rectangle

width

Width of the clip rectangle

height

Height of the clip rectangle

pub fn set_clip_to_allocation(&self, clip_set: bool)[src]

Sets whether self should be clipped to the same size as its allocation

clip_set

true to apply a clip tracking the allocation

pub fn set_content<P>(&self, content: Option<&P>) where
    P: IsA<Content>, 
[src]

Sets the contents of a Actor.

content

a Content, or None

pub fn set_content_gravity(&self, gravity: ContentGravity)[src]

Sets the gravity of the Content used by self.

See the description of the Actor:content-gravity property for more information.

The Actor:content-gravity property is animatable.

gravity

the ContentGravity

pub fn set_content_repeat(&self, repeat: ContentRepeat)[src]

Sets the policy for repeating the Actor:content of a Actor. The behaviour is deferred to the Content implementation.

repeat

the repeat policy

pub fn set_content_scaling_filters(
    &self,
    min_filter: ScalingFilter,
    mag_filter: ScalingFilter
)
[src]

Sets the minification and magnification filter to be applied when scaling the Actor:content of a Actor.

The Actor:minification-filter will be used when reducing the size of the content; the Actor:magnification-filter will be used when increasing the size of the content.

min_filter

the minification filter for the content

mag_filter

the magnification filter for the content

pub fn set_easing_delay(&self, msecs: u32)[src]

Sets the delay that should be applied before tweening animatable properties.

msecs

the delay before the start of the tweening, in milliseconds

pub fn set_easing_duration(&self, msecs: u32)[src]

Sets the duration of the tweening for animatable properties of self for the current easing state.

msecs

the duration of the easing, or None

pub fn set_easing_mode(&self, mode: AnimationMode)[src]

Sets the easing mode for the tweening of animatable properties of self.

mode

an easing mode, excluding AnimationMode::CustomMode

pub fn set_fixed_position_set(&self, is_set: bool)[src]

Sets whether an actor has a fixed position set (and will thus be unaffected by any layout manager).

is_set

whether to use fixed position

pub fn set_flags(&self, flags: ActorFlags)[src]

Sets flags on self

This function will emit notifications for the changed properties

flags

the flags to set

pub fn set_height(&self, height: f32)[src]

Forces a height on an actor, causing the actor’s preferred width and height (if any) to be ignored.

If height is -1 the actor will use its preferred height instead of overriding it, i.e. you can “unset” the height with -1.

This function sets both the minimum and natural size of the actor.

height

Requested new height for the actor, in pixels, or -1

pub fn set_layout_manager<P>(&self, manager: Option<&P>) where
    P: IsA<LayoutManager>, 
[src]

Sets the LayoutManager delegate object that will be used to lay out the children of self.

The Actor will take a reference on the passed manager which will be released either when the layout manager is removed, or when the actor is destroyed.

manager

a LayoutManager, or None to unset it

pub fn set_margin(&self, margin: &Margin)[src]

Sets all the components of the margin of a Actor.

margin

a Margin

pub fn set_margin_bottom(&self, margin: f32)[src]

Sets the margin from the bottom of a Actor.

The Actor:margin-bottom property is animatable.

margin

the bottom margin

pub fn set_margin_left(&self, margin: f32)[src]

Sets the margin from the left of a Actor.

The Actor:margin-left property is animatable.

margin

the left margin

pub fn set_margin_right(&self, margin: f32)[src]

Sets the margin from the right of a Actor.

The Actor:margin-right property is animatable.

margin

the right margin

pub fn set_margin_top(&self, margin: f32)[src]

Sets the margin from the top of a Actor.

The Actor:margin-top property is animatable.

margin

the top margin

pub fn set_name(&self, name: &str)[src]

Sets the given name to self. The name can be used to identify a Actor.

name

Textual tag to apply to actor

pub fn set_offscreen_redirect(&self, redirect: OffscreenRedirect)[src]

Defines the circumstances where the actor should be redirected into an offscreen image. The offscreen image is used to flatten the actor into a single image while painting for two main reasons. Firstly, when the actor is painted a second time without any of its contents changing it can simply repaint the cached image without descending further down the actor hierarchy. Secondly, it will make the opacity look correct even if there are overlapping primitives in the actor.

Caching the actor could in some cases be a performance win and in some cases be a performance lose so it is important to determine which value is right for an actor before modifying this value. For example, there is never any reason to flatten an actor that is just a single texture (such as a Texture) because it is effectively already cached in an image so the offscreen would be redundant. Also if the actor contains primitives that are far apart with a large transparent area in the middle (such as a large CluterGroup with a small actor in the top left and a small actor in the bottom right) then the cached image will contain the entire image of the large area and the paint will waste time blending all of the transparent pixels in the middle.

The default method of implementing opacity on a container simply forwards on the opacity to all of the children. If the children are overlapping then it will appear as if they are two separate glassy objects and there will be a break in the color where they overlap. By redirecting to an offscreen buffer it will be as if the two opaque objects are combined into one and then made transparent which is usually what is expected.

The image below demonstrates the difference between redirecting and not. The image shows two groups, each containing a red and a green rectangle which overlap. The opacity on the group is set to 128 (which is 50%). When the offscreen redirect is not used, the red rectangle can be seen through the blue rectangle as if the two rectangles were separately transparent. When the redirect is used the group as a whole is transparent instead so the red rectangle is not visible where they overlap.

``Sample of using an offscreen redirect for transparency`` `
`

The default value for this property is 0, so we effectively will never redirect an actor offscreen by default. This means that there are times that transparent actors may look glassy as described above. The reason this is the default is because there is a performance trade off between quality and performance here. In many cases the default form of glassy opacity looks good enough, but if it’s not you will need to set the OffscreenRedirect::AutomaticForOpacity flag to enable redirection for opacity.

Custom actors that don’t contain any overlapping primitives are recommended to override the has_overlaps virtual to return false for maximum efficiency.

redirect

New offscreen redirect flags for the actor.

pub fn set_opacity(&self, opacity: u8)[src]

Sets the actor’s opacity, with zero being completely transparent and 255 (0xff) being fully opaque.

The Actor:opacity property is animatable.

opacity

New opacity value for the actor.

pub fn set_pivot_point(&self, pivot_x: f32, pivot_y: f32)[src]

Sets the position of the Actor:pivot-point around which the scaling and rotation transformations occur.

The pivot point’s coordinates are in normalized space, with the (0, 0) point being the top left corner of the actor, and the (1, 1) point being the bottom right corner.

pivot_x

the normalized X coordinate of the pivot point

pivot_y

the normalized Y coordinate of the pivot point

pub fn set_pivot_point_z(&self, pivot_z: f32)[src]

Sets the component on the Z axis of the Actor:pivot-point around which the scaling and rotation transformations occur.

The pivot_z value is expressed as a distance along the Z axis.

pivot_z

the Z coordinate of the actor’s pivot point

pub fn set_position(&self, x: f32, y: f32)[src]

Sets the actor’s fixed position in pixels relative to any parent actor.

If a layout manager is in use, this position will override the layout manager and force a fixed position.

x

New left position of actor in pixels.

y

New top position of actor in pixels.

pub fn set_reactive(&self, reactive: bool)[src]

Sets self as reactive. Reactive actors will receive events.

reactive

whether the actor should be reactive to events

pub fn set_request_mode(&self, mode: RequestMode)[src]

Sets the geometry request mode of self.

The mode determines the order for invoking ActorExt::get_preferred_width and ActorExt::get_preferred_height

mode

the request mode

pub fn set_rotation_angle(&self, axis: RotateAxis, angle: f64)[src]

Sets the angle of rotation of a Actor on the given axis.

This function is a convenience for setting the rotation properties Actor:rotation-angle-x, Actor:rotation-angle-y, and Actor:rotation-angle-z.

The center of rotation is established by the Actor:pivot-point property.

axis

the axis to set the angle one

angle

the angle of rotation, in degrees

pub fn set_scale(&self, scale_x: f64, scale_y: f64)[src]

Scales an actor with the given factors.

The scale transformation is relative the the Actor:pivot-point.

The Actor:scale-x and Actor:scale-y properties are animatable.

scale_x

double factor to scale actor by horizontally.

scale_y

double factor to scale actor by vertically.

pub fn set_scale_z(&self, scale_z: f64)[src]

Scales an actor on the Z axis by the given scale_z factor.

The scale transformation is relative the the Actor:pivot-point.

The Actor:scale-z property is animatable.

scale_z

the scaling factor along the Z axis

pub fn set_size(&self, width: f32, height: f32)[src]

Sets the actor’s size request in pixels. This overrides any “normal” size request the actor would have. For example a text actor might normally request the size of the text; this function would force a specific size instead.

If width and/or height are -1 the actor will use its “normal” size request instead of overriding it, i.e. you can “unset” the size with -1.

This function sets or unsets both the minimum and natural size.

width

New width of actor in pixels, or -1

height

New height of actor in pixels, or -1

pub fn set_text_direction(&self, text_dir: TextDirection)[src]

Sets the TextDirection for an actor

The passed text direction must not be TextDirection::Default

If self implements Container then this function will recurse inside all the children of self (including the internal ones).

Composite actors not implementing Container, or actors requiring special handling when the text direction changes, should connect to the gobject::Object::notify signal for the Actor:text-direction property

text_dir

the text direction for self

pub fn set_transform(&self, transform: Option<&Matrix>)[src]

Overrides the transformations of a Actor with a custom matrix, which will be applied relative to the origin of the actor’s allocation and to the actor’s pivot point.

The Actor:transform property is animatable.

transform

a Matrix, or None to unset a custom transformation

pub fn set_translation(
    &self,
    translate_x: f32,
    translate_y: f32,
    translate_z: f32
)
[src]

Sets an additional translation transformation on a Actor, relative to the Actor:pivot-point.

translate_x

the translation along the X axis

translate_y

the translation along the Y axis

translate_z

the translation along the Z axis

pub fn set_width(&self, width: f32)[src]

Forces a width on an actor, causing the actor’s preferred width and height (if any) to be ignored.

If width is -1 the actor will use its preferred width request instead of overriding it, i.e. you can “unset” the width with -1.

This function sets both the minimum and natural size of the actor.

width

Requested new width for the actor, in pixels, or -1

pub fn set_x(&self, x: f32)[src]

Sets the actor’s X coordinate, relative to its parent, in pixels.

Overrides any layout manager and forces a fixed position for the actor.

The Actor:x property is animatable.

x

the actor’s position on the X axis

pub fn set_x_align(&self, x_align: ActorAlign)[src]

Sets the horizontal alignment policy of a Actor, in case the actor received extra horizontal space.

See also the Actor:x-align property.

x_align

the horizontal alignment policy

pub fn set_x_expand(&self, expand: bool)[src]

Sets whether a Actor should expand horizontally; this means that layout manager should allocate extra space for the actor, if possible.

Setting an actor to expand will also make all its parent expand, so that it’s possible to build an actor tree and only set this flag on its leaves and not on every single actor.

expand

whether the actor should expand horizontally

pub fn set_y(&self, y: f32)[src]

Sets the actor’s Y coordinate, relative to its parent, in pixels.#

Overrides any layout manager and forces a fixed position for the actor.

The Actor:y property is animatable.

y

the actor’s position on the Y axis

pub fn set_y_align(&self, y_align: ActorAlign)[src]

Sets the vertical alignment policy of a Actor, in case the actor received extra vertical space.

See also the Actor:y-align property.

y_align

the vertical alignment policy

pub fn set_y_expand(&self, expand: bool)[src]

Sets whether a Actor should expand horizontally; this means that layout manager should allocate extra space for the actor, if possible.

Setting an actor to expand will also make all its parent expand, so that it’s possible to build an actor tree and only set this flag on its leaves and not on every single actor.

expand

whether the actor should expand vertically

pub fn set_z_position(&self, z_position: f32)[src]

Sets the actor’s position on the Z axis.

See Actor:z-position.

z_position

the position on the Z axis

pub fn should_pick_paint(&self) -> bool[src]

Should be called inside the implementation of the Actor::pick virtual function in order to check whether the actor should paint itself in pick mode or not.

This function should never be called directly by applications.

Returns

true if the actor should paint its silhouette, false otherwise

pub fn show(&self)[src]

Flags an actor to be displayed. An actor that isn’t shown will not be rendered on the stage.

Actors are visible by default.

If this function is called on an actor without a parent, the Actor:show-on-set-parent will be set to true as a side effect.

pub fn transform_stage_point(&self, x: f32, y: f32) -> Option<(f32, f32)>[src]

This function translates screen coordinates (x, y) to coordinates relative to the actor. For example, it can be used to translate screen events from global screen coordinates into actor-local coordinates.

The conversion can fail, notably if the transform stack results in the actor being projected on the screen as a mere line.

The conversion should not be expected to be pixel-perfect due to the nature of the operation. In general the error grows when the skewing of the actor rectangle on screen increases.

This function can be computationally intensive.

This function only works when the allocation is up-to-date, i.e. inside of the ActorClass.paint() implementation

x

x screen coordinate of the point to unproject

y

y screen coordinate of the point to unproject

x_out

return location for the unprojected x coordinance

y_out

return location for the unprojected y coordinance

Returns

true if conversion was successful.

pub fn unmap(&self)[src]

Unsets the ActorFlags::Mapped flag on the actor and possibly unmaps its children if they were mapped.

Calling this function is not encouraged: the default Actor implementation of ActorClass.unmap() will also unmap any eventual children by default when their parent is unmapped.

When overriding ActorClass.unmap(), it is mandatory to chain up to the parent implementation.

It is important to note that the implementation of the ActorClass.unmap() virtual function may be called after the ActorClass.destroy() or the gobject::ObjectClass.dispose() implementation, but it is guaranteed to be called before the gobject::ObjectClass.finalize() implementation.

pub fn unset_flags(&self, flags: ActorFlags)[src]

Unsets flags on self

This function will emit notifications for the changed properties

flags

the flags to unset

pub fn set_property_actions<P>(&self, actions: Option<&P>) where
    P: IsA<Action> + SetValueOptional
[src]

Adds a Action to the actor

pub fn get_property_allocation(&self) -> Option<ActorBox>[src]

The allocation for the actor, in pixels

This is property is read-only, but you might monitor it to know when an actor moves or resizes

pub fn get_property_background_color_set(&self) -> bool[src]

Whether the Actor:background-color property has been set.

pub fn get_property_child_transform_set(&self) -> bool[src]

Whether the Actor:child-transform property is set.

pub fn get_property_clip_rect(&self) -> Option<InternalRect>[src]

The visible region of the actor, in actor-relative coordinates, expressed as a Rect.

Setting this property to None will unset the existing clip.

Setting this property will change the Actor:has-clip property as a side effect.

pub fn set_property_clip_rect(&self, clip_rect: Option<&InternalRect>)[src]

The visible region of the actor, in actor-relative coordinates, expressed as a Rect.

Setting this property to None will unset the existing clip.

Setting this property will change the Actor:has-clip property as a side effect.

pub fn set_property_constraints<P>(&self, constraints: Option<&P>) where
    P: IsA<Constraint> + SetValueOptional
[src]

Adds a Constraint to the actor

pub fn set_property_effect<P>(&self, effect: Option<&P>) where
    P: IsA<Effect> + SetValueOptional
[src]

Adds Effect to the list of effects be applied on a Actor

pub fn get_property_fixed_x(&self) -> f32[src]

The fixed X position of the actor in pixels.

Writing this property sets Actor:fixed-position-set property as well, as a side effect

pub fn set_property_fixed_x(&self, fixed_x: f32)[src]

The fixed X position of the actor in pixels.

Writing this property sets Actor:fixed-position-set property as well, as a side effect

pub fn get_property_fixed_y(&self) -> f32[src]

The fixed Y position of the actor in pixels.

Writing this property sets the Actor:fixed-position-set property as well, as a side effect

pub fn set_property_fixed_y(&self, fixed_y: f32)[src]

The fixed Y position of the actor in pixels.

Writing this property sets the Actor:fixed-position-set property as well, as a side effect

pub fn get_property_has_clip(&self) -> bool[src]

Whether the actor has the Actor:clip property set or not

pub fn get_property_has_pointer(&self) -> bool[src]

Whether the actor contains the pointer of a InputDevice or not.

pub fn get_property_magnification_filter(&self) -> ScalingFilter[src]

pub fn set_property_magnification_filter(
    &self,
    magnification_filter: ScalingFilter
)
[src]

pub fn get_property_mapped(&self) -> bool[src]

Whether the actor is mapped (will be painted when the stage to which it belongs is mapped)

pub fn get_property_min_height(&self) -> f32[src]

A forced minimum height request for the actor, in pixels

Writing this property sets the Actor:min-height-set property as well, as a side effect. This property overrides the usual height request of the actor.

pub fn set_property_min_height(&self, min_height: f32)[src]

A forced minimum height request for the actor, in pixels

Writing this property sets the Actor:min-height-set property as well, as a side effect. This property overrides the usual height request of the actor.

pub fn get_property_min_height_set(&self) -> bool[src]

This flag controls whether the Actor:min-height property is used

pub fn set_property_min_height_set(&self, min_height_set: bool)[src]

This flag controls whether the Actor:min-height property is used

pub fn get_property_min_width(&self) -> f32[src]

A forced minimum width request for the actor, in pixels

Writing this property sets the Actor:min-width-set property as well, as a side effect.

This property overrides the usual width request of the actor.

pub fn set_property_min_width(&self, min_width: f32)[src]

A forced minimum width request for the actor, in pixels

Writing this property sets the Actor:min-width-set property as well, as a side effect.

This property overrides the usual width request of the actor.

pub fn get_property_min_width_set(&self) -> bool[src]

This flag controls whether the Actor:min-width property is used

pub fn set_property_min_width_set(&self, min_width_set: bool)[src]

This flag controls whether the Actor:min-width property is used

pub fn get_property_minification_filter(&self) -> ScalingFilter[src]

pub fn set_property_minification_filter(
    &self,
    minification_filter: ScalingFilter
)
[src]

pub fn get_property_natural_height(&self) -> f32[src]

A forced natural height request for the actor, in pixels

Writing this property sets the Actor:natural-height-set property as well, as a side effect. This property overrides the usual height request of the actor

pub fn set_property_natural_height(&self, natural_height: f32)[src]

A forced natural height request for the actor, in pixels

Writing this property sets the Actor:natural-height-set property as well, as a side effect. This property overrides the usual height request of the actor

pub fn get_property_natural_height_set(&self) -> bool[src]

This flag controls whether the Actor:natural-height property is used

pub fn set_property_natural_height_set(&self, natural_height_set: bool)[src]

This flag controls whether the Actor:natural-height property is used

pub fn get_property_natural_width(&self) -> f32[src]

A forced natural width request for the actor, in pixels

Writing this property sets the Actor:natural-width-set property as well, as a side effect. This property overrides the usual width request of the actor

pub fn set_property_natural_width(&self, natural_width: f32)[src]

A forced natural width request for the actor, in pixels

Writing this property sets the Actor:natural-width-set property as well, as a side effect. This property overrides the usual width request of the actor

pub fn get_property_natural_width_set(&self) -> bool[src]

This flag controls whether the Actor:natural-width property is used

pub fn set_property_natural_width_set(&self, natural_width_set: bool)[src]

This flag controls whether the Actor:natural-width property is used

pub fn get_property_realized(&self) -> bool[src]

Whether the actor has been realized

pub fn get_property_rotation_angle_x(&self) -> f64[src]

The rotation angle on the X axis.

The Actor:rotation-angle-x property is animatable.

pub fn set_property_rotation_angle_x(&self, rotation_angle_x: f64)[src]

The rotation angle on the X axis.

The Actor:rotation-angle-x property is animatable.

pub fn get_property_rotation_angle_y(&self) -> f64[src]

The rotation angle on the Y axis

The Actor:rotation-angle-y property is animatable.

pub fn set_property_rotation_angle_y(&self, rotation_angle_y: f64)[src]

The rotation angle on the Y axis

The Actor:rotation-angle-y property is animatable.

pub fn get_property_rotation_angle_z(&self) -> f64[src]

The rotation angle on the Z axis

The Actor:rotation-angle-z property is animatable.

pub fn set_property_rotation_angle_z(&self, rotation_angle_z: f64)[src]

The rotation angle on the Z axis

The Actor:rotation-angle-z property is animatable.

pub fn get_property_scale_x(&self) -> f64[src]

The horizontal scale of the actor.

The Actor:scale-x property is animatable.

pub fn set_property_scale_x(&self, scale_x: f64)[src]

The horizontal scale of the actor.

The Actor:scale-x property is animatable.

pub fn get_property_scale_y(&self) -> f64[src]

The vertical scale of the actor.

The Actor:scale-y property is animatable.

pub fn set_property_scale_y(&self, scale_y: f64)[src]

The vertical scale of the actor.

The Actor:scale-y property is animatable.

pub fn get_property_show_on_set_parent(&self) -> bool[src]

If true, the actor is automatically shown when parented.

Calling ActorExt::hide on an actor which has not been parented will set this property to false as a side effect.

pub fn set_property_show_on_set_parent(&self, show_on_set_parent: bool)[src]

If true, the actor is automatically shown when parented.

Calling ActorExt::hide on an actor which has not been parented will set this property to false as a side effect.

pub fn get_property_transform_set(&self) -> bool[src]

Whether the Actor:transform property is set.

pub fn get_property_translation_x(&self) -> f32[src]

An additional translation applied along the X axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-x property is animatable.

pub fn set_property_translation_x(&self, translation_x: f32)[src]

An additional translation applied along the X axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-x property is animatable.

pub fn get_property_translation_y(&self) -> f32[src]

An additional translation applied along the Y axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-y property is animatable.

pub fn set_property_translation_y(&self, translation_y: f32)[src]

An additional translation applied along the Y axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-y property is animatable.

pub fn get_property_translation_z(&self) -> f32[src]

An additional translation applied along the Z axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-z property is animatable.

pub fn set_property_translation_z(&self, translation_z: f32)[src]

An additional translation applied along the Z axis, relative to the actor’s Actor:pivot-point.

The Actor:translation-z property is animatable.

pub fn get_property_visible(&self) -> bool[src]

Whether the actor is set to be visible or not

See also Actor:mapped

pub fn set_property_visible(&self, visible: bool)[src]

Whether the actor is set to be visible or not

See also Actor:mapped

pub fn connect_allocation_changed<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &ActorBox, AllocationFlags), 
[src]

The ::allocation-changed signal is emitted when the Actor:allocation property changes. Usually, application code should just use the notifications for the :allocation property but if you want to track the allocation flags as well, for instance to know whether the absolute origin of actor changed, then you might want use this signal instead.

box_

a ActorBox with the new allocation

flags

AllocationFlags for the allocation

pub fn connect_button_press_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &ButtonEvent) -> bool
[src]

The ::button-press-event signal is emitted each time a mouse button is pressed on actor.

event

a ButtonEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_button_release_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &ButtonEvent) -> bool
[src]

The ::button-release-event signal is emitted each time a mouse button is released on actor.

event

a ButtonEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_captured_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &Event) -> bool
[src]

The ::captured-event signal is emitted when an event is captured. This signal will be emitted starting from the top-level container (the Stage) to the actor which received the event going down the hierarchy. This signal can be used to intercept every event before the specialized events (like Actor::button-press-event or ::key-released-event) are emitted.

event

a Event

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_destroy<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::destroy signal notifies that all references held on the actor which emitted it should be released.

The ::destroy signal should be used by all holders of a reference on actor.

This signal might result in the finalization of the Actor if all references are released.

Composite actors and actors implementing the Container interface should override the default implementation of the class handler of this signal and call ActorExt::destroy on their children. When overriding the default class handler, it is required to chain up to the parent’s implementation.

pub fn connect_enter_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &CrossingEvent) -> bool
[src]

The ::enter-event signal is emitted when the pointer enters the actor

event

a CrossingEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &Event) -> bool
[src]

The ::event signal is emitted each time an event is received by the actor. This signal will be emitted on every actor, following the hierarchy chain, until it reaches the top-level container (the Stage).

event

a Event

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_hide<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::hide signal is emitted when an actor is no longer rendered on the stage.

pub fn connect_key_focus_in<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::key-focus-in signal is emitted when actor receives key focus.

pub fn connect_key_focus_out<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::key-focus-out signal is emitted when actor loses key focus.

pub fn connect_key_press_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &KeyEvent) -> bool
[src]

The ::key-press-event signal is emitted each time a keyboard button is pressed while actor has key focus (see StageExt::set_key_focus).

event

a KeyEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_key_release_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &KeyEvent) -> bool
[src]

The ::key-release-event signal is emitted each time a keyboard button is released while actor has key focus (see StageExt::set_key_focus).

event

a KeyEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_leave_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &CrossingEvent) -> bool
[src]

The ::leave-event signal is emitted when the pointer leaves the actor.

event

a CrossingEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_motion_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &MotionEvent) -> bool
[src]

The ::motion-event signal is emitted each time the mouse pointer is moved over actor.

event

a MotionEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_parent_set<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, Option<&Actor>), 
[src]

This signal is emitted when the parent of the actor changes.

old_parent

the previous parent of the actor, or None

pub fn connect_queue_redraw<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &Actor), 
[src]

The ::queue_redraw signal is emitted when ActorExt::queue_redraw is called on origin.

The default implementation for Actor chains up to the parent actor and queues a redraw on the parent, thus “bubbling” the redraw queue up through the actor graph. The default implementation for Stage queues a StageExt::ensure_redraw in a main loop idle handler.

Note that the origin actor may be the stage, or a container; it does not have to be a leaf node in the actor graph.

Toolkits embedding a Stage which require a redraw and relayout cycle can stop the emission of this signal using the GSignal API, redraw the UI and then call StageExt::ensure_redraw themselves, like:

  static void
  on_redraw_complete (gpointer data)
  {
    Stage *stage = data;

    // execute the drawing pipeline
    stage_ensure_redraw (stage);
  }

  static void
  on_stage_queue_redraw (Stage *stage)
  {
    // this prevents the default handler to run
    g_signal_stop_emission_by_name (stage, "queue-redraw");

    // queue a redraw with the host toolkit and call
    // a function when the redraw has been completed
    queue_a_redraw (G_CALLBACK (on_redraw_complete), stage);
  }

Note: This signal is emitted before the paint pipeline is executed. If you want to know when the pipeline has been completed you should use threads_add_repaint_func or threads_add_repaint_func_full.

origin

the actor which initiated the redraw request

pub fn connect_queue_relayout<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::queue_layout signal is emitted when ActorExt::queue_relayout is called on an actor.

The default implementation for Actor chains up to the parent actor and queues a relayout on the parent, thus “bubbling” the relayout queue up through the actor graph.

The main purpose of this signal is to allow relayout to be propagated properly in the presence of Clone actors. Applications will not normally need to connect to this signal.

pub fn connect_scroll_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &ScrollEvent) -> bool
[src]

The ::scroll-event signal is emitted each time the mouse is scrolled on actor

event

a ScrollEvent

Returns

true if the event has been handled by the actor, or false to continue the emission.

pub fn connect_show<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::show signal is emitted when an actor is visible and rendered on the stage.

pub fn connect_touch_event<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &Event) -> bool
[src]

The ::touch-event signal is emitted each time a touch begin/end/update/cancel event.

event

a Event

Returns

EVENT_STOP if the event has been handled by the actor, or EVENT_PROPAGATE to continue the emission.

pub fn connect_transition_stopped<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self, &str, bool), 
[src]

The ::transition-stopped signal is emitted once a transition is stopped; a transition is stopped once it reached its total duration (including eventual repeats), it has been stopped using TimelineExt::stop, or it has been removed from the transitions applied on actor, using ActorExt::remove_transition.

name

the name of the transition

is_finished

whether the transition was finished, or stopped

pub fn connect_transitions_completed<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

The ::transitions-completed signal is emitted once all transitions involving actor are complete.

pub fn connect_property_actions_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_allocation_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_background_color_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_background_color_set_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_child_transform_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_child_transform_set_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_clip_rect_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_clip_to_allocation_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_constraints_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_content_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_content_box_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_content_gravity_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_content_repeat_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_effect_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_first_child_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_fixed_position_set_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_fixed_x_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_fixed_y_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_has_clip_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_has_pointer_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_height_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_last_child_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_layout_manager_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_magnification_filter_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_mapped_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_margin_bottom_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_margin_left_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_margin_right_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_margin_top_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_min_height_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_min_height_set_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_min_width_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_min_width_set_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_minification_filter_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_name_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_natural_height_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_natural_height_set_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_natural_width_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_natural_width_set_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_offscreen_redirect_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_opacity_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_pivot_point_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_pivot_point_z_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_position_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_reactive_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_realized_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_request_mode_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_rotation_angle_x_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_rotation_angle_y_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_rotation_angle_z_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_scale_x_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_scale_y_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_scale_z_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_show_on_set_parent_notify<F>(
    &self,
    f: F
) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_size_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_text_direction_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_transform_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_transform_set_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_translation_x_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_translation_y_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_translation_z_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_visible_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_width_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_x_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_x_align_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_x_expand_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_y_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_y_align_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_y_expand_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

pub fn connect_property_z_position_notify<F>(&self, f: F) -> SignalHandlerId where
    F: 'static + Fn(&Self), 
[src]

Loading content...

Implementors

impl<O> ActorExt for O where
    O: IsA<Actor>, 
[src]

Loading content...