Class (GI Class)

Shell-18 ▶ Shell ▶ SquareBin

Type Parameters

Hierarchy (View Summary)

Implements

Index

Constructors

constructor

Properties

$signals $gtype

Properties - Inherited from Shell.Stack

flags

Accessors - Inherited from St

accessible_name accessible_role accessibleName accessibleRole actions allocation background_color background_color_set backgroundColor backgroundColorSet can_focus canFocus child child_transform child_transform_set childTransform childTransformSet clip_rect clip_to_allocation clipRect clipToAllocation color_state colorState constraints content content_box content_gravity content_repeat contentBox contentGravity contentRepeat context cursor_type cursorType effect first_child firstChild fixed_position_set fixed_x fixed_y fixedPositionSet fixedX fixedY has_clip has_pointer hasClip hasPointer height hover label_actor labelActor last_child lastChild layout_manager layoutManager magnification_filter magnificationFilter mapped margin_bottom margin_left margin_right margin_top marginBottom marginLeft marginRight marginTop min_height min_height_set min_width min_width_set minHeight minHeightSet minification_filter minificationFilter minWidth minWidthSet name natural_height natural_height_set natural_width natural_width_set naturalHeight naturalHeightSet naturalWidth naturalWidthSet offscreen_redirect offscreenRedirect opacity pivot_point pivot_point_z pivotPoint pivotPointZ position pseudo_class pseudoClass reactive realized request_mode requestMode rotation_angle_x rotation_angle_y rotation_angle_z rotationAngleX rotationAngleY rotationAngleZ scale_x scale_y scale_z scaleX scaleY scaleZ show_on_set_parent showOnSetParent size style style_class styleClass text_direction textDirection track_hover trackHover transform transform_set transformSet translation_x translation_y translation_z translationX translationY translationZ visible width x x_align x_expand xAlign xExpand y y_align y_expand yAlign yExpand z_position zPosition

Methods

_init connect connect_after emit

Methods - Inherited from St

add_accessible_state add_action add_action_full add_action_with_name add_child add_constraint add_constraint_with_name add_effect add_effect_with_name add_style_class_name add_style_pseudo_class add_transition allocate allocate_align_fill allocate_available_size allocate_preferred_size apply_relative_transform_to_point apply_transform_to_point bind_model bind_property bind_property_full block_signal_handler clear_actions clear_constraints clear_effects contains continue_paint continue_pick create_pango_context create_pango_layout create_texture_paint_node destroy destroy_all_children disconnect ensure_style event find_property force_floating freeze_notify get_abs_allocation_vertices get_accessible get_accessible_name get_accessible_role get_action get_actions get_actor get_allocation_box get_background_color get_can_focus get_child get_child_at_index get_child_transform get_children get_clip get_clip_to_allocation get_color_state get_constraint get_constraints get_content get_content_box get_content_gravity get_content_repeat get_content_scaling_filters get_context get_cursor_type get_data get_easing_delay get_easing_duration get_easing_mode get_effect get_effects get_first_child get_fixed_position get_fixed_position_set get_focus_chain get_height get_hover get_initial_state get_label_actor get_last_child get_layout_manager get_margin get_margin_bottom get_margin_left get_margin_right get_margin_top get_n_children get_name get_next_sibling get_offscreen_redirect get_opacity get_opacity_override get_paint_box get_paint_opacity get_paint_visibility get_paint_volume get_pango_context get_parent get_pivot_point get_pivot_point_z get_position get_preferred_height get_preferred_size get_preferred_width get_previous_sibling get_property get_qdata get_reactive get_request_mode get_resource_scale get_rotation_angle get_scale get_scale_z get_size get_stage get_style get_style_class_name get_style_pseudo_class get_text_direction get_theme_node get_track_hover get_transform get_transformed_extents get_transformed_paint_volume get_transformed_position get_transformed_size get_transition get_translation get_width get_x get_x_align get_x_expand get_y get_y_align get_y_expand get_z_position getv grab_key_focus has_actions has_allocation has_constraints has_effects has_key_focus has_mapped_clones has_overlaps has_style_class_name has_style_pseudo_class hide inhibit_culling insert_child_above insert_child_at_index insert_child_below interpolate_value invalidate_paint_volume invalidate_transform is_floating is_in_clone_paint is_mapped is_no_layout is_realized is_rotated is_scaled is_visible map move_by navigate_focus needs_expand notify notify_by_pspec paint paint_background peek_stage_views peek_theme_node pick pick_box popup_menu queue_redraw queue_redraw_with_clip queue_relayout realize ref ref_sink remove_accessible_state remove_action remove_action_by_name remove_all_children remove_all_transitions remove_child remove_clip remove_constraint remove_constraint_by_name remove_effect remove_effect_by_name remove_style_class_name remove_style_pseudo_class remove_transition replace_child restore_easing_state run_dispose save_easing_state set set_accessible set_accessible_name set_accessible_role set_allocation set_background_color set_can_focus set_child set_child_above_sibling set_child_at_index set_child_below_sibling set_child_transform set_clip set_clip_to_allocation set_color_state set_content set_content_gravity set_content_repeat set_content_scaling_filters set_cursor_type set_data set_easing_delay set_easing_duration set_easing_mode set_final_state set_fixed_position_set set_height set_hover set_label_actor set_layout_manager set_margin set_margin_bottom set_margin_left set_margin_right set_margin_top set_name set_no_layout set_offscreen_redirect set_opacity set_opacity_override set_pivot_point set_pivot_point_z set_position set_property set_reactive set_request_mode set_rotation_angle set_scale set_scale_z set_size set_style set_style_class_name set_style_pseudo_class set_text_direction set_track_hover set_transform set_translation set_width set_x set_x_align set_x_expand set_y set_y_align set_y_expand set_z_position should_pick show steal_data steal_qdata stop_emission_by_name style_changed sync_hover thaw_notify transform_stage_point unblock_signal_handler uninhibit_culling unmap unrealize unref unset_color_state vfunc_allocate vfunc_apply_transform vfunc_button_press_event vfunc_button_release_event vfunc_calculate_resource_scale vfunc_captured_event vfunc_child_added vfunc_child_removed vfunc_constructed vfunc_destroy vfunc_dispatch_properties_changed vfunc_dispose vfunc_enter_event vfunc_event vfunc_finalize vfunc_find_property vfunc_get_accessible vfunc_get_actor vfunc_get_focus_chain vfunc_get_initial_state vfunc_get_paint_volume vfunc_get_preferred_height vfunc_get_preferred_width vfunc_get_property vfunc_has_overlaps vfunc_hide vfunc_hide_all vfunc_interpolate_value vfunc_key_focus_in vfunc_key_focus_out vfunc_key_press_event vfunc_key_release_event vfunc_leave_event vfunc_map vfunc_motion_event vfunc_navigate_focus vfunc_notify vfunc_paint vfunc_paint_node vfunc_parent_set vfunc_pick vfunc_popup_menu vfunc_queue_relayout vfunc_realize vfunc_resource_scale_changed vfunc_scroll_event vfunc_set_final_state vfunc_set_property vfunc_show vfunc_style_changed vfunc_touch_event vfunc_unmap vfunc_unrealize watch_closure _classInit compat_control find_property get_binding_pool get_layout_manager_type install_properties install_property interface_find_property interface_install_property interface_list_properties list_properties new newv override_property set_layout_manager_type

Constructors

Properties

$signals: Shell.SquareBin.SignalSignatures

Compile-time signal type information.

This instance property is generated only for TypeScript type checking. It is not defined at runtime and should not be accessed in JS code.

$gtype: GType<
    Shell.SquareBin<Clutter.Actor<Clutter.LayoutManager, Clutter.Content>>,
>

Properties - Inherited from Shell.Stack

flags: number

Accessors - Inherited from St

  • get accessible_name(): string

    Object instance's name for assistive technology access.

    Returns string

    null
  • set accessible_name(val: string): void

    Parameters

    • val: string

    Returns void

  • get accessibleName(): string

    Object instance's name for assistive technology access.

    Returns string

    null
  • set accessibleName(val: string): void

    Parameters

    • val: string

    Returns void

  • get allocation(): ActorBox

    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

    Returns ActorBox

  • get can_focus(): boolean

    Whether or not the widget can be focused via keyboard navigation.

    Returns boolean

    false
  • set can_focus(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get canFocus(): boolean

    Whether or not the widget can be focused via keyboard navigation.

    Returns boolean

    false
  • set canFocus(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get clip_to_allocation(): boolean

    Whether the clip region should track the allocated area of the actor.

    This property is ignored if a clip area has been explicitly set using clutter_actor_set_clip().

    Returns boolean

    false
  • set clip_to_allocation(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get clipToAllocation(): boolean

    Whether the clip region should track the allocated area of the actor.

    This property is ignored if a clip area has been explicitly set using clutter_actor_set_clip().

    Returns boolean

    false
  • set clipToAllocation(val: boolean): void

    Parameters

    • val: boolean

    Returns void

content

content_box

content_gravity

content_repeat

  • get height(): number

    Height of the actor (in pixels). If written, forces the minimum and natural size request of the actor to the given height. If read, returns the allocated height if available, otherwise the height request.

    The Clutter.Actor.height property is animatable.

    Returns number

    0
  • set height(val: number): void

    Parameters

    • val: number

    Returns void

  • get hover(): boolean

    Whether or not the pointer is currently hovering over the widget. This is only tracked automatically if St.Widget.track_hover is true, but you can adjust it manually in any case.

    Returns boolean

    false
  • set hover(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get mapped(): boolean

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

    Returns boolean

    false
  • get margin_bottom(): number

    The margin (in pixels) from the bottom of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_bottom property is animatable.

    Returns number

    0
  • set margin_bottom(val: number): void

    Parameters

    • val: number

    Returns void

  • get margin_left(): number

    The margin (in pixels) from the left of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_left property is animatable.

    Returns number

    0
  • set margin_left(val: number): void

    Parameters

    • val: number

    Returns void

  • get margin_right(): number

    The margin (in pixels) from the right of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_right property is animatable.

    Returns number

    0
  • set margin_right(val: number): void

    Parameters

    • val: number

    Returns void

  • get margin_top(): number

    The margin (in pixels) from the top of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_top property is animatable.

    Returns number

    0
  • set margin_top(val: number): void

    Parameters

    • val: number

    Returns void

  • get marginBottom(): number

    The margin (in pixels) from the bottom of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_bottom property is animatable.

    Returns number

    0
  • set marginBottom(val: number): void

    Parameters

    • val: number

    Returns void

  • get marginLeft(): number

    The margin (in pixels) from the left of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_left property is animatable.

    Returns number

    0
  • set marginLeft(val: number): void

    Parameters

    • val: number

    Returns void

  • get marginRight(): number

    The margin (in pixels) from the right of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_right property is animatable.

    Returns number

    0
  • set marginRight(val: number): void

    Parameters

    • val: number

    Returns void

  • get marginTop(): number

    The margin (in pixels) from the top of the actor.

    This property adds a margin to the actor's preferred size; the margin will be automatically taken into account when allocating the actor.

    The Clutter.Actor.margin_top property is animatable.

    Returns number

    0
  • set marginTop(val: number): void

    Parameters

    • val: number

    Returns void

  • get min_height(): number

    A forced minimum height request for the actor, in pixels

    Writing this property sets the Clutter.Actor.min_height_set property as well, as a side effect. This property overrides the usual height request of the actor.

    Returns number

    0
  • set min_height(val: number): void

    Parameters

    • val: number

    Returns void

  • get min_width(): number

    A forced minimum width request for the actor, in pixels

    Writing this property sets the Clutter.Actor.min_width_set property as well, as a side effect.

    This property overrides the usual width request of the actor.

    Returns number

    0
  • set min_width(val: number): void

    Parameters

    • val: number

    Returns void

  • get minHeight(): number

    A forced minimum height request for the actor, in pixels

    Writing this property sets the Clutter.Actor.min_height_set property as well, as a side effect. This property overrides the usual height request of the actor.

    Returns number

    0
  • set minHeight(val: number): void

    Parameters

    • val: number

    Returns void

  • get minWidth(): number

    A forced minimum width request for the actor, in pixels

    Writing this property sets the Clutter.Actor.min_width_set property as well, as a side effect.

    This property overrides the usual width request of the actor.

    Returns number

    0
  • set minWidth(val: number): void

    Parameters

    • val: number

    Returns void

  • get natural_height(): number

    A forced natural height request for the actor, in pixels

    Writing this property sets the Clutter.Actor.natural_height_set property as well, as a side effect. This property overrides the usual height request of the actor

    Returns number

    0
  • set natural_height(val: number): void

    Parameters

    • val: number

    Returns void

  • get natural_width(): number

    A forced natural width request for the actor, in pixels

    Writing this property sets the Clutter.Actor.natural_width_set property as well, as a side effect. This property overrides the usual width request of the actor

    Returns number

    0
  • set natural_width(val: number): void

    Parameters

    • val: number

    Returns void

  • get naturalHeight(): number

    A forced natural height request for the actor, in pixels

    Writing this property sets the Clutter.Actor.natural_height_set property as well, as a side effect. This property overrides the usual height request of the actor

    Returns number

    0
  • set naturalHeight(val: number): void

    Parameters

    • val: number

    Returns void

  • get naturalWidth(): number

    A forced natural width request for the actor, in pixels

    Writing this property sets the Clutter.Actor.natural_width_set property as well, as a side effect. This property overrides the usual width request of the actor

    Returns number

    0
  • set naturalWidth(val: number): void

    Parameters

    • val: number

    Returns void

  • get pseudo_class(): string

    The pseudo-class of the actor. Typical values include "hover", "active", "focus".

    Returns string

  • set pseudo_class(val: string): void

    Parameters

    • val: string

    Returns void

  • get pseudoClass(): string

    The pseudo-class of the actor. Typical values include "hover", "active", "focus".

    Returns string

  • set pseudoClass(val: string): void

    Parameters

    • val: string

    Returns void

  • get reactive(): boolean

    Whether the actor is reactive to events or not

    Only reactive actors will emit event-related signals

    Returns boolean

    false
  • set reactive(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get realized(): boolean

    Whether the actor has been realized

    Returns boolean

    false
  • get request_mode(): Clutter.RequestMode

    Request mode for the Clutter.Actor. The request mode determines the type of geometry management used by the actor, either height for width (the default) or width for height.

    For actors implementing height for width, the parent container should get the preferred width first, and then the preferred height for that width.

    For actors implementing width for height, the parent container should get the preferred height first, and then the preferred width for that height.

    For instance:

      ClutterRequestMode mode;
      gfloat natural_width, min_width;
      gfloat natural_height, min_height;

      mode = clutter_actor_get_request_mode (child);
      if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
        {
          clutter_actor_get_preferred_width (child, -1,
                                             &min_width,
                                             &natural_width);
          clutter_actor_get_preferred_height (child, natural_width,
                                              &min_height,
                                              &natural_height);
        }
      else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
        {
          clutter_actor_get_preferred_height (child, -1,
                                              &min_height,
                                              &natural_height);
          clutter_actor_get_preferred_width (child, natural_height,
                                             &min_width,
                                             &natural_width);
        }
      else if (mode == CLUTTER_REQUEST_CONTENT_SIZE)
        {
          ClutterContent *content = clutter_actor_get_content (child);

          min_width, min_height = 0;
          natural_width = natural_height = 0;

          if (content != NULL)
            clutter_content_get_preferred_size (content, &natural_width, &natural_height);
        }

    will retrieve the minimum and natural width and height depending on the preferred request mode of the Clutter.Actor "child".

    The Clutter.Actor.get_preferred_size function will implement this check for you.

    Returns Clutter.RequestMode

    Clutter.RequestMode.HEIGHT_FOR_WIDTH
  • set request_mode(val: Clutter.RequestMode): void

    Parameters

    Returns void

  • get requestMode(): Clutter.RequestMode

    Request mode for the Clutter.Actor. The request mode determines the type of geometry management used by the actor, either height for width (the default) or width for height.

    For actors implementing height for width, the parent container should get the preferred width first, and then the preferred height for that width.

    For actors implementing width for height, the parent container should get the preferred height first, and then the preferred width for that height.

    For instance:

      ClutterRequestMode mode;
      gfloat natural_width, min_width;
      gfloat natural_height, min_height;

      mode = clutter_actor_get_request_mode (child);
      if (mode == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
        {
          clutter_actor_get_preferred_width (child, -1,
                                             &min_width,
                                             &natural_width);
          clutter_actor_get_preferred_height (child, natural_width,
                                              &min_height,
                                              &natural_height);
        }
      else if (mode == CLUTTER_REQUEST_WIDTH_FOR_HEIGHT)
        {
          clutter_actor_get_preferred_height (child, -1,
                                              &min_height,
                                              &natural_height);
          clutter_actor_get_preferred_width (child, natural_height,
                                             &min_width,
                                             &natural_width);
        }
      else if (mode == CLUTTER_REQUEST_CONTENT_SIZE)
        {
          ClutterContent *content = clutter_actor_get_content (child);

          min_width, min_height = 0;
          natural_width = natural_height = 0;

          if (content != NULL)
            clutter_content_get_preferred_size (content, &natural_width, &natural_height);
        }

    will retrieve the minimum and natural width and height depending on the preferred request mode of the Clutter.Actor "child".

    The Clutter.Actor.get_preferred_size function will implement this check for you.

    Returns Clutter.RequestMode

    Clutter.RequestMode.HEIGHT_FOR_WIDTH
  • set requestMode(val: Clutter.RequestMode): void

    Parameters

    Returns void

  • get show_on_set_parent(): boolean

    If true, the actor is automatically shown when parented.

    Calling clutter_actor_hide() on an actor which has not been parented will set this property to false as a side effect.

    Returns boolean

    true
  • set show_on_set_parent(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get showOnSetParent(): boolean

    If true, the actor is automatically shown when parented.

    Calling clutter_actor_hide() on an actor which has not been parented will set this property to false as a side effect.

    Returns boolean

    true
  • set showOnSetParent(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get style(): string | null

    Inline style information for the actor as a ';'-separated list of CSS properties.

    Returns string | null

  • set style(val: string | null): void

    Parameters

    • val: string | null

    Returns void

  • get style_class(): string

    The style-class of the actor for use in styling.

    Returns string

  • set style_class(val: string): void

    Parameters

    • val: string

    Returns void

  • get styleClass(): string

    The style-class of the actor for use in styling.

    Returns string

  • set styleClass(val: string): void

    Parameters

    • val: string

    Returns void

text_direction

  • get track_hover(): boolean

    Determines whether the widget tracks pointer hover state. If true (and the widget is visible and reactive), the St.Widget.hover property and "hover" style pseudo class will be adjusted automatically as the pointer moves in and out of the widget.

    Returns boolean

    false
  • set track_hover(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get trackHover(): boolean

    Determines whether the widget tracks pointer hover state. If true (and the widget is visible and reactive), the St.Widget.hover property and "hover" style pseudo class will be adjusted automatically as the pointer moves in and out of the widget.

    Returns boolean

    false
  • set trackHover(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get width(): number

    Width of the actor (in pixels). If written, forces the minimum and natural size request of the actor to the given width. If read, returns the allocated width if available, otherwise the width request.

    The Clutter.Actor.width property is animatable.

    Returns number

    0
  • set width(val: number): void

    Parameters

    • val: number

    Returns void

  • get x(): number

    X coordinate of the actor in pixels. If written, forces a fixed position for the actor. If read, returns the fixed position if any, otherwise the allocation if available, otherwise 0.

    The Clutter.Actor.x property is animatable.

    Returns number

    0
  • set x(val: number): void

    Parameters

    • val: number

    Returns void

  • get x_expand(): boolean

    Whether a layout manager should assign more space to the actor on the X axis.

    Returns boolean

    false
  • set x_expand(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get xExpand(): boolean

    Whether a layout manager should assign more space to the actor on the X axis.

    Returns boolean

    false
  • set xExpand(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get y(): number

    Y coordinate of the actor in pixels. If written, forces a fixed position for the actor. If read, returns the fixed position if any, otherwise the allocation if available, otherwise 0.

    The Clutter.Actor.y property is animatable.

    Returns number

    0
  • set y(val: number): void

    Parameters

    • val: number

    Returns void

  • get y_expand(): boolean

    Whether a layout manager should assign more space to the actor on the Y axis.

    Returns boolean

    false
  • set y_expand(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get yExpand(): boolean

    Whether a layout manager should assign more space to the actor on the Y axis.

    Returns boolean

    false
  • set yExpand(val: boolean): void

    Parameters

    • val: boolean

    Returns void

  • get z_position(): number

    The actor's position on the Z axis, relative to the parent's transformations.

    Positive values will bring the actor's position nearer to the user, whereas negative values will bring the actor's position farther from the user.

    The Clutter.Actor.z_position does not affect the paint or allocation order.

    The Clutter.Actor.z_position property is animatable.

    Returns number

    0
  • set z_position(val: number): void

    Parameters

    • val: number

    Returns void

  • get zPosition(): number

    The actor's position on the Z axis, relative to the parent's transformations.

    Positive values will bring the actor's position nearer to the user, whereas negative values will bring the actor's position farther from the user.

    The Clutter.Actor.z_position does not affect the paint or allocation order.

    The Clutter.Actor.z_position property is animatable.

    Returns number

    0
  • set zPosition(val: number): void

    Parameters

    • val: number

    Returns void

Methods

_init

Methods - Inherited from St

  • This method adds state as one of the accessible states for actor. The list of states of an actor describes the current state of user interface element actor and is provided so that assistive technologies know how to present actor to the user.

    Usually you will have no need to add accessible states for an object, as the accessible object can extract most of the states from the object itself. This method is only required when one cannot extract the information automatically from the object itself (i.e.: a generic container used as a toggle menu item will not automatically include the toggled state).

    Parameters

    Returns void

  • Adds style_class to actor's style class name list, if it is not already present.

    Parameters

    • style_class: string

      a style class name string

    Returns void

  • Adds pseudo_class to actor's pseudo class list, if it is not already present.

    Parameters

    • pseudo_class: string

      a pseudo class string

    Returns void

  • 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 Clutter.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 Clutter.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 Clutter.Actor.x_align and Clutter.Actor.y_align properties, instead, and just call Clutter.Actor.allocate inside their Clutter.Actor.allocate implementation.

    Parameters

    • box: ActorBox

      a Clutter.ActorBox, containing the available width and height

    • x_align: number

      the horizontal alignment, between 0 and 1

    • y_align: number

      the vertical alignment, between 0 and 1

    • x_fill: boolean

      whether the actor should fill horizontally

    • y_fill: boolean

      whether the actor should fill vertically

    Returns void

  • Allocates self taking into account the Clutter.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 == CLUTTER_REQUEST_HEIGHT_FOR_WIDTH)
        {
          clutter_actor_get_preferred_width (self, available_height,
                                             &min_width,
                                             &natural_width);
          width = CLAMP (natural_width, min_width, available_width);

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

          clutter_actor_get_preferred_width (self, height,
                                             &min_width,
                                             &natural_width);
          width = CLAMP (natural_width, min_width, available_width);
        }
      else if (request_mode == CLUTTER_REQUEST_CONTENT_SIZE)
        {
          clutter_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;
      clutter_actor_allocate (self, &box);

    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.

    Parameters

    • x: number

      the actor's X coordinate

    • y: number

      the actor's Y coordinate

    • available_width: number

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

    • available_height: number

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

    Returns void

  • Allocates the natural size of self.

    This function is a utility call for Clutter.Actor implementations that allocates the actor's preferred natural size. It can be used by fixed layout managers (like ClutterGroup or so called 'composite actors') inside the Clutter.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 Clutter.ActorClass.allocate virtual function.

    Parameters

    • x: number

      the actor's X coordinate

    • y: number

      the actor's Y coordinate

    Returns void

  • Creates a binding between source_property on source and target_property on target.

    Whenever the source_property is changed the target_property is updated using the same value. For instance:

      g_object_bind_property (action, "active", widget, "sensitive", 0);

    Will result in the "sensitive" property of the widget GObject.Object instance to be updated with the same value of the "active" property of the action GObject.Object instance.

    If flags contains GObject.BindingFlags.BIDIRECTIONAL then the binding will be mutual: if target_property on target changes then the source_property on source will be updated as well.

    The binding will automatically be removed when either the source or the target instances are finalized. To remove the binding without affecting the source and the target you can just call g_object_unref() on the returned GObject.Binding instance.

    Removing the binding by calling g_object_unref() on it must only be done if the binding, source and target are only used from a single thread and it is clear that both source and target outlive the binding. Especially it is not safe to rely on this if the binding, source or target can be finalized from different threads. Keep another reference to the binding and use g_binding_unbind() instead to be on the safe side.

    A GObject.Object can have multiple bindings.

    Parameters

    Returns GObject.Binding

    the GObject.Binding instance representing the binding between the two GObject.Object instances. The binding is released whenever the GObject.Binding reference count reaches zero.

  • 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.

    Parameters

    Returns boolean

    whether descendent is contained within self

  • Run the next stage of the paint sequence. This function should only be called within the implementation of the ‘run’ virtual of a Clutter.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.

    Parameters

    Returns void

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

    Parameters

    Returns void

  • Creates a new Pango.Layout from the same Pango.Context used by the Clutter.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 Clutter.Backend.SignalSignatures.font_changed | Clutter.Backend::font-changed and Clutter.Backend.SignalSignatures.resolution_changed | Clutter.Backend::resolution-changed signals, and call pango_layout_context_changed() in response to them.

    Parameters

    • text: string | null

      the text to set on the Pango.Layout, or null

    Returns Pango.Layout

    the newly created Pango.Layout. Use g_object_unref() when done

  • 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.

    Returns void

  • 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 Clutter.Actor::destroy signal is emitted on each child of the actor.

    By default, Clutter.Actor will emit the Clutter.Actor::destroy signal when its reference count drops to 0; the default handler of the Clutter.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 Clutter.Actor.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 Clutter.Actor.remove_all_children and want to reuse the actors, you should use Clutter.Actor.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.

    Returns void

  • Disconnects a handler from an instance so it will not be called during any future or currently ongoing emissions of the signal it has been connected to.

    Parameters

    • id: number

      Handler ID of the handler to be disconnected

    Returns void

  • Ensures that widget has read its style information and propagated any changes to its children.

    Returns void

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

    Parameters

    Returns boolean

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

  • Increases the freeze count on object. If the freeze count is non-zero, the emission of "notify" signals on object is stopped. The signals are queued until the freeze count is decreased to zero. Duplicate notifications are squashed so that at most one GObject.Object::notify signal is emitted for each property modified while the object is frozen.

    This is necessary for accessors that modify multiple properties to prevent premature notification while the object is still being modified.

    Returns void

  • Gets the accessible name for this widget. See clutter_actor_set_accessible_name() for more information.

    Returns string

    a character string representing the accessible name of the widget.

  • 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 translation; those transformations do not affect layout, only rendering.

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

    Returns ActorBox

  • Returns the current value of the can-focus property. See st_widget_set_can_focus() for more information.

    Returns boolean

    current value of can-focus on widget

get_content

get_content_box

get_content_gravity

get_content_repeat

get_content_scaling_filters

  • Gets a named field from the objects table of associations (see g_object_set_data()).

    Parameters

    • key: string

      name of the key for that association

    Returns any

    the data if found, or null if no such data exists.

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

    Returns number

    the duration of the tweening, in milliseconds

  • This function gets the fixed position of the actor, if set. If there is no fixed position set, this function returns false and doesn't set the x and y coordinates.

    Returns [boolean, number, number]

    true if the fixed position is set, false if it isn't

  • Retrieves the height of a Clutter.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 Clutter.Actor.get_allocation_box to retrieve the allocated size Clutter.Actor.get_preferred_height to retrieve the preferred height.

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

    Returns number

    the height of the actor, in pixels

  • Retrieves the current state of property_name and sets value with it

    Parameters

    • property_name: string

      the name of the animatable property to retrieve

    • value: any

      a GObject.Value initialized to the type of the property to retrieve

    Returns void

  • Retrieves the name of self.

    Returns string | null

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

  • Retrieves the opacity value of an actor, as set by clutter_actor_set_opacity().

    For retrieving the absolute opacity of the actor inside a paint virtual function, see clutter_actor_get_paint_opacity().

    Returns number

    the opacity of the actor

  • Retrieves the paint volume of the passed Clutter.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.

    Returns [boolean, ActorBox]

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

  • 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 number

    The actor opacity value.

  • Retrieves the 'paint' visibility of an actor recursively checking for non visible parents.

    This is by definition the same as clutter_actor_is_mapped.

    Returns boolean

    true if the actor is visible and will be painted.

  • 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.

    Returns [number, number]

  • 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 translation; those transformations do not affect layout, only rendering.

    Parameters

    • for_width: number

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

    Returns [number, number]

  • 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 scaleor translation; those transformations do not affect layout, only rendering.

    Parameters

    • for_height: number

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

    Returns [number, number]

  • Gets a property of an object.

    The value can be:

    • an empty GObject.Value initialized by G_VALUE_INIT, which will be automatically initialized with the expected type of the property (since GLib 2.60)
    • a GObject.Value initialized with the expected type of the property
    • a GObject.Value initialized with a type to which the expected type of the property can be transformed

    In general, a copy is made of the property contents and the caller is responsible for freeing the memory by calling GObject.Value.unset.

    Note that GObject.Object.get_property is really intended for language bindings, GObject.Object.get is much more convenient for C programming.

    Parameters

    • property_name: string

      The name of the property to get

    • value: any

      Return location for the property value. Can be an empty GObject.Value initialized by G_VALUE_INIT (auto-initialized with expected type since GLib 2.60), a GObject.Value initialized with the expected property type, or a GObject.Value initialized with a transformable type

    Returns any

  • Retrieves the resource scale for this actor.

    The resource scale refers to the scale the actor should use for its resources. For example if an actor draws a a picture of size 100 x 100 in the stage coordinate space, it should use a texture of twice the size (i.e. 200 x 200) if the resource scale is 2.

    The resource scale is determined by calculating the highest Clutter.StageView scale the actor will get painted on.

    Note that the scale returned by this function is only guaranteed to be correct when queried during the paint cycle, in all other cases this function will only return a best guess. If your implementation really needs to get a resource scale outside of the paint cycle, make sure to subscribe to the "resource-scale-changed" signal to get notified about the new, correct resource scale before painting.

    Also avoid getting the resource scale for actors that are not attached to a stage. There's no sane way for Clutter to guess which Clutter.StageView the actor is going to be painted on, so you'll probably end up receiving the "resource-scale-changed" signal and having to rebuild your resources.

    The best guess this function may return is usually just the last resource scale the actor got painted with. If this resource scale couldn't be found because the actor was never painted so far or Clutter was unable to determine its position and size, this function will return the resource scale of a parent.

    Returns number

    The resource scale the actor should use for its textures

  • Get the current inline style string. See st_widget_set_style().

    Returns string | null

    The inline style string, or null. The string is owned by the St.Widget and should not be modified or freed.

  • Get the current style pseudo class list.

    Note that an actor can have multiple pseudo classes; if you just want to test for the presence of a specific pseudo class, use st_widget_has_style_pseudo_class().

    Returns string

    the pseudo class list string. The string is owned by the St.Widget and should not be modified or freed.

get_text_direction

  • Gets the theme node holding style information for the widget. The theme node is used to access standard and custom CSS properties of the widget.

    Note: it is a fatal error to call this on a widget that is not been added to a stage.

    Returns St.ThemeNode

    the theme node for the widget. This is owned by the widget. When attributes of the widget or the environment that affect the styling change (for example the style_class property of the widget), it will be recreated, and the ::style-changed signal will be emitted on the widget.

  • Gets the transformed bounding rect of an actor, in pixels relative to the stage. Using this outside of paint() may result in outdated results.

    The result can only be assumed valid inside a paint() method, or an allocate() function of an actor that explicitly gets allocated after self; anywhere else, it may be out-of-date.

    Returns Graphene.Rect

  • 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 Clutter.Actor.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 Clutter.Actor.get_transformed_position; if you need this information, you need to use Clutter.Actor.get_abs_allocation_vertices to get the coords of the actual quadrangle.

    Returns [number, number]

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

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

      clutter_actor_set_easing_duration (actor, 1000);
      clutter_actor_set_rotation_angle (actor, CLUTTER_Y_AXIS, 360.0);

      transition = clutter_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 Clutter.Actor::transition-stopped signal, using the transition name as the signal detail.

    Parameters

    • name: string

      the name of the transition

    Returns Clutter.Transition | null

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

  • Retrieves the width of a Clutter.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 Clutter.Actor.get_allocation_box to retrieve the allocated size Clutter.Actor.get_preferred_width to retrieve the preferred width.

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

    Returns number

    the width of the actor, in pixels

  • Retrieves the X coordinate of a Clutter.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 Clutter.Actor.set_x, Clutter.Actor.set_position, this function will return that coordinate.

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

    Returns number

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

  • Retrieves the Y coordinate of a Clutter.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 Clutter.Actor.set_y, Clutter.Actor.set_position, this function will return that coordinate.

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

    Returns number

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

  • Gets n_properties properties for an object. Obtained properties will be set to values. All properties must be valid. Warnings will be emitted and undefined behaviour may result if invalid properties are passed in.

    Parameters

    • names: string[]

      the names of each property to get

    • values: any[]

      the values of each property to get

    Returns void

  • 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 boolean

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

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

    For example; Clutter 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 Clutter.Actor.has_overlaps. See Clutter.Actor.set_offscreen_redirect for more information.

    Returns boolean

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

  • Tests if actor's style class list includes style_class.

    Parameters

    • style_class: string

      a style class string

    Returns boolean

    whether or not actor's style class list includes style_class.

  • Tests if actor's pseudo class list includes pseudo_class.

    Parameters

    • pseudo_class: string

      a pseudo class string

    Returns boolean

    whether or not actor's pseudo class list includes pseudo_class.

  • Increases the culling inhibitor counter. Inhibiting culling forces the actor to be painted even when outside the visible bounds of the stage view.

    This is usually necessary when an actor is being painted on another paint context.

    Pair with clutter_actor_uninhibit_culling() when the actor doesn't need to be painted anymore.

    Returns void

  • 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 Clutter.Actor.remove_child.

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

    This function will emit the Clutter.Actor::child-added signal on self.

    Parameters

    Returns void

  • Asks a Clutter.Animatable implementation to interpolate a a named property between the initial and final values of a Clutter.Interval, using progress as the interpolation value, and store the result inside value.

    This function should be used for every property animation involving Clutter.Animatables.

    Parameters

    • property_name: string

      the name of the property to interpolate

    • interval: Clutter.Interval

      a Clutter.Interval with the animation range

    • progress: number

      the progress to use to interpolate between the initial and final values of the interval

    Returns [boolean, unknown]

    true if the interpolation was successful, and false otherwise

  • Invalidate the cached transformation matrix of self. This is needed for implementations overriding the apply_transform() vfunc and has to be called if the matrix returned by apply_transform() would change.

    Returns void

  • Checks whether actor is marked as no layout.

    That means the actor provides an explicit layout management policy for its children; this will prevent Clutter from automatic queueing of relayout and will defer all layouting to the actor itself

    Returns boolean

    true if the actor is marked as no layout

  • Sets the CLUTTER_ACTOR_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 discouraged: the default implementation of Clutter.Actor.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.

    Returns void

  • 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 additional translation, using clutter_actor_set_translation().

    Parameters

    • dx: number

      Distance to move Actor on X axis.

    • dy: number

      Distance to move Actor on Y axis.

    Returns void

  • Tries to update the keyboard focus within widget in response to a keyboard event.

    If from is a descendant of widget, this attempts to move the keyboard focus to the next descendant of widget (in the order implied by direction) that has the St.Widget.can_focus property set. If from is null, this attempts to focus either widget itself, or its first descendant in the order implied by direction. If from is outside of widget, it behaves as if it was a descendant if direction is one of the directional arrows and as if it was null otherwise.

    If a container type is marked St.Widget.can_focus, the expected behavior is that it will only take up a single slot on the focus chain as a whole, rather than allowing navigation between its child actors (or having a distinction between itself being focused and one of its children being focused).

    Some widget classes might have slightly different behavior from the above, where that would make more sense.

    If wrap_around is true and from is a child of widget, but the widget has no further children that can accept the focus in the given direction, then st_widget_navigate_focus() will try a second time, using a null from, which should cause it to reset the focus to the first available widget in the given direction.

    Parameters

    Returns boolean

    true if clutter_actor_grab_key_focus() has been called on an actor. false if not.

  • Emits a "notify" signal for the property property_name on object.

    When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.

    Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.

    Parameters

    • property_name: string

      the name of a property installed on the class of object.

    Returns void

  • Emits a "notify" signal for the property specified by pspec on object.

    This function omits the property name lookup, hence it is faster than g_object_notify().

    One way to avoid using g_object_notify() from within the class that registered the properties, and using g_object_notify_by_pspec() instead, is to store the GParamSpec used with g_object_class_install_property() inside a static array, e.g.:

      typedef enum
      {
        PROP_FOO = 1,
        PROP_LAST
      } MyObjectProperty;

      static GParamSpec *properties[PROP_LAST];

      static void
      my_object_class_init (MyObjectClass *klass)
      {
        properties[PROP_FOO] = g_param_spec_int ("foo", NULL, NULL,
                                                 0, 100,
                                                 50,
                                                 G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
        g_object_class_install_property (gobject_class,
                                         PROP_FOO,
                                         properties[PROP_FOO]);
      }

    and then notify a change on the "foo" property with:

      g_object_notify_by_pspec (self, properties[PROP_FOO]);

    Parameters

    Returns void

  • Renders the actor to display.

    This function should not be called directly by applications. Call clutter_actor_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 call the Clutter.Actor.paint virtual function.

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

    Parameters

    Returns void

  • Retrieves the list of Clutter.StageViews the actor is being painted on.

    If this function is called during the paint cycle, the list is guaranteed to be up-to-date, if called outside the paint cycle, the list will contain the views the actor was painted on last.

    The list returned by this function is not updated when the actors visibility changes: If an actor gets hidden and is not being painted anymore, this function will return the list of views the actor was painted on last.

    If an actor is not attached to a stage (realized), this function will always return an empty list.

    Returns Clutter.StageView[]

    The list of Clutter.StageViews the actor is being painted on. The list and its contents are owned by the Clutter.Actor and the list may not be freed or modified.

  • Returns the theme node for the widget if it has already been computed, null if the widget hasn't been added to a stage or the theme node hasn't been computed. If null is returned, then ::style-changed will be reliably emitted before the widget is allocated or painted.

    Returns St.ThemeNode

    the theme node for the widget. This is owned by the widget. When attributes of the widget or the environment that affect the styling change (for example the style_class property of the widget), it will be recreated, and the ::style-changed signal will be emitted on the widget.

  • Logs (does a virtual paint of) a rectangle for picking. Note that box is in the actor's own local coordinates, so is usually {0,0,width,height} to include the whole actor. That is unless the actor has a shaped input region in which case you may wish to log the (multiple) smaller rectangles that make up the input region.

    Parameters

    Returns void

  • Asks the widget to pop-up a context menu by emitting St.Widget.SignalSignatures.popup_menu | St.Widget::popup-menu.

    Returns void

  • 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.

    Returns void

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

    Queueing a new layout automatically queues a redraw as well.

    Returns void

  • Realization informs the actor that it is attached to a stage. It can use this to allocate resources if it wanted to delay allocation until it would be rendered. However it is perfectly acceptable for an actor to create resources before being realized because Clutter only ever has a single rendering context so that actor is free to be moved from one stage to another.

    This function does nothing if the actor is already realized.

    Because a realized actor must have realized parent actors, calling clutter_actor_realize() will also realize all parents of the actor.

    This function does not realize child actors, except in the special case that realizing the stage, when the stage is visible, will suddenly map (and thus realize) the children of the stage.

    Returns void

  • Increases the reference count of object.

    Since GLib 2.56, if GLIB_VERSION_MAX_ALLOWED is 2.56 or greater, the type of object will be propagated to the return type (using the GCC typeof() extension), so any casting the caller needs to do on the return type must be explicit.

    Returns GObject.Object

    the same object

  • Increase the reference count of object, and possibly remove the [floating][floating-ref] reference, if object has a floating reference.

    In other words, if the object is floating, then this call "assumes ownership" of the floating reference, converting it to a normal reference by clearing the floating flag while leaving the reference count unchanged. If the object is not floating, then this call adds a new normal reference increasing the reference count by one.

    Since GLib 2.56, the type of object will be propagated to the return type under the same conditions as for g_object_ref().

    Returns GObject.Object

    object

  • 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 clutter_actor_destroy_all_children().

    Returns void

  • Removes style_class from actor's style class name, if it is present.

    Parameters

    • style_class: string

      a style class name string

    Returns void

  • Removes pseudo_class from actor's pseudo class, if it is present.

    Parameters

    • pseudo_class: string

      a pseudo class string

    Returns void

  • Removes the transition stored inside a Clutter.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 Clutter.Actor.

    Parameters

    • name: string

      the name of the transition to remove

    Returns void

  • 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.

    Returns void

  • Sets multiple properties of an object at once. The properties argument should be a dictionary mapping property names to values.

    Parameters

    • properties: { [key: string]: any }

      Object containing the properties to set

    Returns void

  • This method allows to set a customly created accessible object to this widget

    NULL is a valid value for accessible. That contemplates the hypothetical case of not needing anymore a custom accessible object for the widget. Next call of Clutter.Actor.get_accessible would create and return a default accessible.

    It assumes that the call to atk_object_initialize that bound the gobject with the custom accessible object was already called, so not a responsibility of this method.

    Parameters

    Returns void

  • This method sets name as the accessible name for self.

    Usually you will have no need to set the accessible name for an object, as usually there is a label for most of the interface elements.

    Parameters

    • name: string | null

      a character string to be set as the accessible name

    Returns void

  • This method sets role as the accessible role for self. This role describes what kind of user interface element self is and is provided so that assistive technologies know how to present self to the user.

    Usually you will have no need to set the accessible role for an object, as this information is extracted from the context of the object (ie: a StButton has by default a push button role). This method is only required when you need to redefine the role currently associated with the widget, for instance if it is being used in an unusual way (ie: a StButton used as a togglebutton), or if a generic object is used directly (ie: a container as a menu item).

    If role is #ATK_ROLE_INVALID, the role will not be changed and the accessible's default role will be used instead.

    Parameters

    Returns void

  • Stores the allocation of self as defined by box.

    This function can only be called from within the implementation of the Clutter.Actor.allocate virtual function.

    The allocation box should have been adjusted to take into account constraints, alignment, and margin properties.

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

    Parameters

    Returns void

  • Marks widget as being able to receive keyboard focus via keyboard navigation.

    Parameters

    • can_focus: boolean

      true if the widget can receive keyboard focus via keyboard navigation

    Returns void

  • Sets child as the child of bin.

    If bin already has a child, the previous child is removed.

    Parameters

    Returns void

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

    This function is logically equivalent to removing child and calling clutter_actor_insert_child_at_index(), but it will not emit signals or change state on child.

    Parameters

    Returns void

  • Sets clip area for self. The clip area is always computed from the upper left corner of the actor.

    Parameters

    • xoff: number

      X offset of the clip rectangle

    • yoff: number

      Y offset of the clip rectangle

    • width: number

      Width of the clip rectangle

    • height: number

      Height of the clip rectangle

    Returns void

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

    Parameters

    • clip_set: boolean

      true to apply a clip tracking the allocation

    Returns void

set_content

set_content_gravity

set_content_repeat

set_content_scaling_filters

  • Each object carries around a table of associations from strings to pointers. This function lets you set an association.

    If the object already had an association with that name, the old association will be destroyed.

    Internally, the key is converted to a GLib.Quark using g_quark_from_string(). This means a copy of key is kept permanently (even after object has been finalized) — so it is recommended to only use a small, bounded set of values for key in your program, to avoid the GLib.Quark storage growing unbounded.

    Parameters

    • key: string

      name of the key

    • data: any

      data to associate with that key

    Returns void

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

    Parameters

    • msecs: number

      the delay before the start of the tweening, in milliseconds

    Returns void

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

    Parameters

    • msecs: number

      the duration of the easing, or null

    Returns void

  • Sets the current state of property_name to value

    Parameters

    • property_name: string

      the name of the animatable property to set

    • value: any

      the value of the animatable property to set

    Returns void

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

    Parameters

    • is_set: boolean

      whether to use fixed position

    Returns void

  • 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.

    Parameters

    • height: number

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

    Returns void

  • Sets widget's hover property and adds or removes "hover" from its pseudo class accordingly.

    If you have set St.Widget.track_hover, you should not need to call this directly. You can call st_widget_sync_hover() if the hover state might be out of sync due to another actor's pointer grab.

    Parameters

    • hover: boolean

      whether the pointer is hovering over the widget

    Returns void

  • 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 ClutterTexture) 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 Clutter 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 Clutter.OffscreenRedirect.AUTOMATIC_FOR_OPACITY 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.

    Parameters

    Returns void

  • Allows overriding the calculated paint opacity (as returned by clutter_actor_get_paint_opacity()). This is used internally by ClutterClone and ClutterOffscreenEffect, and should be used by actors that need to mimic those.

    In almost all cases this should not used by applications.

    Parameters

    • opacity: number

      the override opacity value, or -1 to reset

    Returns void

  • Sets the position of the Clutter.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.

    Parameters

    • pivot_x: number

      the normalized X coordinate of the pivot point

    • pivot_y: number

      the normalized Y coordinate of the pivot point

    Returns void

  • Sets the component on the Z axis of the Clutter.Actor.pivot_point around which the scaling and rotation transformations occur.

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

    Parameters

    • pivot_z: number

      the Z coordinate of the actor's pivot point

    Returns void

  • 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.

    Parameters

    • x: number

      New left position of actor in pixels.

    • y: number

      New top position of actor in pixels.

    Returns void

  • Sets actor as reactive. Reactive actors will receive events.

    Parameters

    • reactive: boolean

      whether the actor should be reactive to events

    Returns void

  • 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.

    Parameters

    • width: number

      New width of actor in pixels, or -1

    • height: number

      New height of actor in pixels, or -1

    Returns void

  • Set the inline style string for this widget. The inline style string is an optional ';'-separated list of CSS properties that override the style as determined from the stylesheets of the current theme.

    Parameters

    • style: string | null

      a inline style string, or null

    Returns void

  • Set the style class name list. style_class_list can either be null, for no classes, or a space-separated list of style class names. See also st_widget_add_style_class_name() and st_widget_remove_style_class_name().

    Parameters

    • style_class_list: string | null

      a new style class list string

    Returns void

  • Set the style pseudo class list. pseudo_class_list can either be null, for no classes, or a space-separated list of pseudo class names. See also st_widget_add_style_pseudo_class() and st_widget_remove_style_pseudo_class().

    Parameters

    • pseudo_class_list: string | null

      a new pseudo class list string

    Returns void

set_text_direction

  • Enables hover tracking on the St.Widget.

    If hover tracking is enabled, and the widget is visible and reactive, then widget's St.Widget.hover property will be updated automatically to reflect whether the pointer is in widget (or one of its children), and widget's St.Widget.pseudo_class will have the "hover" class added and removed from it accordingly.

    Note that currently it is not possible to correctly track the hover state when another actor has a pointer grab. You can use st_widget_sync_hover() to update the property manually in this case.

    Parameters

    • track_hover: boolean

      true if the widget should track the pointer hover state

    Returns void

  • Sets an additional translation transformation on a Clutter.Actor, relative to the Clutter.Actor.pivot_point.

    Parameters

    • translate_x: number

      the translation along the X axis

    • translate_y: number

      the translation along the Y axis

    • translate_z: number

      the translation along the Z axis

    Returns void

  • 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.

    Parameters

    • width: number

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

    Returns void

  • 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 Clutter.Actor.x property is animatable.

    Parameters

    • x: number

      the actor's position on the X axis

    Returns void

  • Sets whether a Clutter.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.

    Parameters

    • expand: boolean

      whether the actor should expand horizontally

    Returns void

  • 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 Clutter.Actor.y property is animatable.

    Parameters

    • y: number

      the actor's position on the Y axis

    Returns void

  • Sets whether a Clutter.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.

    Parameters

    • expand: boolean

      whether the actor should expand vertically

    Returns void

  • Remove a specified datum from the object's data associations, without invoking the association's destroy handler.

    Parameters

    • key: string

      name of the key

    Returns any

    the data if found, or null if no such data exists.

  • This function gets back user data pointers stored via g_object_set_qdata() and removes the data from object without invoking its destroy() function (if any was set). Usually, calling this function is only required to update user data pointers with a destroy notifier, for example:

    void
    object_add_to_user_list (GObject     *object,
                             const gchar *new_string)
    {
      // the quark, naming the object data
      GQuark quark_string_list = g_quark_from_static_string ("my-string-list");
      // retrieve the old string list
      GList *list = g_object_steal_qdata (object, quark_string_list);

      // prepend new string
      list = g_list_prepend (list, g_strdup (new_string));
      // this changed 'list', so we need to set it again
      g_object_set_qdata_full (object, quark_string_list, list, free_string_list);
    }
    static void
    free_string_list (gpointer data)
    {
      GList *node, *list = data;

      for (node = list; node; node = node->next)
        g_free (node->data);
      g_list_free (list);
    }

    Using g_object_get_qdata() in the above example, instead of g_object_steal_qdata() would have left the destroy function set, and thus the partial string list would have been freed upon g_object_set_qdata_full().

    Parameters

    • quark: number

      A GLib.Quark, naming the user data pointer

    Returns any

    The user data pointer set, or null

  • Sets widget's hover state according to the current pointer position. This can be used to ensure that it is correct after (or during) a pointer grab.

    Returns void

  • Reverts the effect of a previous call to g_object_freeze_notify(). The freeze count is decreased on object and when it reaches zero, queued "notify" signals are emitted.

    Duplicate notifications for each property are squashed so that at most one GObject.Object::notify signal is emitted for each property, in the reverse order in which they have been queued.

    It is an error to call this function when the freeze count is zero.

    Returns void

  • 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 Clutter.Actor.paint implementation

    Parameters

    • x: number

      x screen coordinate of the point to unproject

    • y: number

      y screen coordinate of the point to unproject

    Returns [boolean, number, number]

    true if conversion was successful.

  • Decreases the culling inhibitor counter. See clutter_actor_inhibit_culling() for when inhibit culling is necessary.

    Calling this function without a matching call to clutter_actor_inhibit_culling() is a programming error.

    Returns void

  • Unsets the CLUTTER_ACTOR_MAPPED flag on the actor and possibly unmaps its children if they were mapped.

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

    When overriding Clutter.Actor.unmap, it is mandatory to chain up to the parent implementation.

    It is important to note that the implementation of the Clutter.Actor.unmap virtual function may be called after the Clutter.Actor.destroy or the GObject.Object.dispose implementation, but it is guaranteed to be called before the GObject.Object.finalize implementation.

    Returns void

  • Unrealization informs the actor that it may be being destroyed or moved to another stage. The actor may want to destroy any underlying graphics resources at this point. However it is perfectly acceptable for it to retain the resources until the actor is destroyed because Clutter only ever uses a single rendering context and all of the graphics resources are valid on any stage.

    Because mapped actors must be realized, actors may not be unrealized if they are mapped. This function hides the actor to be sure it isn't mapped, an application-visible side effect that you may not be expecting.

    This function should not be called by application code.

    This function should not really be in the public API, because there isn't a good reason to call it. ClutterActor will already unrealize things for you when it's important to do so.

    If you were using clutter_actor_unrealize() in a dispose implementation, then don't, just chain up to ClutterActor's dispose.

    If you were using clutter_actor_unrealize() to implement unrealizing children of your container, then don't, ClutterActor will already take care of that.

    Returns void

  • Decreases the reference count of object. When its reference count drops to 0, the object is finalized (i.e. its memory is freed).

    If the pointer to the GObject.Object may be reused in future (for example, if it is an instance variable of another object), it is recommended to clear the pointer to null rather than retain a dangling pointer to a potentially invalid GObject.Object instance. Use g_clear_object() for this.

    Returns void

  • virtual function, used when applying the transformations to an actor before painting it or when transforming coordinates or the allocation; if the transformation calculated by this function may have changed, the cached transformation must be invalidated by calling clutter_actor_invalidate_transform(); it must chain up to the parent's implementation

    Parameters

    Returns void

  • the constructed function is called by g_object_new() as the final step of the object creation process. At the point of the call, all construction properties have been set on the object. The purpose of this call is to allow for object initialisation steps that can only be performed after construction properties have been set. constructed implementors should chain up to the constructed call of their parent class to allow it to complete its initialisation.

    Returns void

  • 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.

    Returns void

  • the dispose function is supposed to drop all references to other objects, but keep the instance otherwise intact, so that client method invocations still work. It may be run multiple times (due to reference loops). Before returning, dispose should chain up to the dispose method of the parent class.

    Returns void

  • 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 translation; those transformations do not affect layout, only rendering.

    Parameters

    • for_width: number

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

    Returns [number, number]

  • 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 scaleor translation; those transformations do not affect layout, only rendering.

    Parameters

    • for_height: number

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

    Returns [number, number]

  • virtual function for containers and composite actors, to determine which children should be shown when calling clutter_actor_hide_all() on the actor. Defaults to calling clutter_actor_hide(). This virtual function is deprecated and it should not be overridden.

    Returns void

  • Sets the CLUTTER_ACTOR_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 discouraged: the default implementation of Clutter.Actor.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.

    Returns void

  • Emits a "notify" signal for the property property_name on object.

    When possible, eg. when signaling a property change from within the class that registered the property, you should use g_object_notify_by_pspec() instead.

    Note that emission of the notify signal may be blocked with g_object_freeze_notify(). In this case, the signal emissions are queued and will be emitted (in reverse order) when g_object_thaw_notify() is called.

    Parameters

    Returns void

  • Renders the actor to display.

    This function should not be called directly by applications. Call clutter_actor_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 call the Clutter.Actor.paint virtual function.

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

    Parameters

    Returns void

  • Asks the widget to pop-up a context menu by emitting St.Widget.SignalSignatures.popup_menu | St.Widget::popup-menu.

    Returns void

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

    Queueing a new layout automatically queues a redraw as well.

    Returns void

  • Realization informs the actor that it is attached to a stage. It can use this to allocate resources if it wanted to delay allocation until it would be rendered. However it is perfectly acceptable for an actor to create resources before being realized because Clutter only ever has a single rendering context so that actor is free to be moved from one stage to another.

    This function does nothing if the actor is already realized.

    Because a realized actor must have realized parent actors, calling clutter_actor_realize() will also realize all parents of the actor.

    This function does not realize child actors, except in the special case that realizing the stage, when the stage is visible, will suddenly map (and thus realize) the children of the stage.

    Returns void

  • Sets the current state of property_name to value

    Parameters

    • property_name: string

      the name of the animatable property to set

    • value: unknown

      the value of the animatable property to set

    Returns void

  • the generic setter for all properties of this type. Should be overridden for every type with properties. If implementations of set_property don't emit property change notification explicitly, this will be done implicitly by the type system. However, if the notify signal is emitted explicitly, the type system will not emit it a second time.

    Parameters

    Returns void

  • Unsets the CLUTTER_ACTOR_MAPPED flag on the actor and possibly unmaps its children if they were mapped.

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

    When overriding Clutter.Actor.unmap, it is mandatory to chain up to the parent implementation.

    It is important to note that the implementation of the Clutter.Actor.unmap virtual function may be called after the Clutter.Actor.destroy or the GObject.Object.dispose implementation, but it is guaranteed to be called before the GObject.Object.finalize implementation.

    Returns void

  • Unrealization informs the actor that it may be being destroyed or moved to another stage. The actor may want to destroy any underlying graphics resources at this point. However it is perfectly acceptable for it to retain the resources until the actor is destroyed because Clutter only ever uses a single rendering context and all of the graphics resources are valid on any stage.

    Because mapped actors must be realized, actors may not be unrealized if they are mapped. This function hides the actor to be sure it isn't mapped, an application-visible side effect that you may not be expecting.

    This function should not be called by application code.

    This function should not really be in the public API, because there isn't a good reason to call it. ClutterActor will already unrealize things for you when it's important to do so.

    If you were using clutter_actor_unrealize() in a dispose implementation, then don't, just chain up to ClutterActor's dispose.

    If you were using clutter_actor_unrealize() to implement unrealizing children of your container, then don't, ClutterActor will already take care of that.

    Returns void

  • This function essentially limits the life time of the closure to the life time of the object. That is, when the object is finalized, the closure is invalidated by calling g_closure_invalidate() on it, in order to prevent invocations of the closure with a finalized (nonexisting) object. Also, g_object_ref() and g_object_unref() are added as marshal guards to the closure, to ensure that an extra reference count is held on object during invocation of the closure. Usually, this function will be called on closures that use this object as closure data.

    Parameters

    Returns void

Static_classInit

  • Add a property to an interface; this is only useful for interfaces that are added to GObject-derived types. Adding a property to an interface forces all objects classes with that interface to have a compatible property. The compatible property could be a newly created GObject.ParamSpec, but normally g_object_class_override_property() will be used so that the object class only needs to provide an implementation and inherits the property description, default value, bounds, and so forth from the interface property.

    This function is meant to be called from the interface's default vtable initialization function (the class_init member of GObject.TypeInfo.) It must not be called after after class_init has been called for any object types implementing this interface.

    If pspec is a floating reference, it will be consumed.

    Parameters

    Returns void

  • Parameters

    • property_id: number

      the new property ID

    • name: string

      the name of a property registered in a parent class or in an interface of this class.

    Returns void

Interfaces

ConstructorProps
SignalSignatures