Index: Functions

@log_critical

@log_debug

@log_fatal

@log_info

@log_warning

Circle

Mousetrap.CircleFunction
Circle(center::Vector2f, radius::Number, n_outer_vertices::Integer) -> Shape

Create a shape as a circle, defined by its center and radius. In OpenGL coordinates.

source

CircularRing

Mousetrap.CircularRingFunction
CircularRing(center::Vector2f, outer_radius::Number, thickness::Number, n_outer_vertices::Integer) -> Shape 

Create a shape as a circular ring, defined by its center, outer_radius, which is the distance to the out perimeter, and thickness which is the distance between the inner and out perimeter.

source

Ellipse

Mousetrap.EllipseFunction
Ellipse(center::Vector2f, x_radius::Number, y_radius::Number, n_outer_vertices::Integer) -> Shape

Create a shape as an ellipse, defined by its center and radii along the x- and y-dimension, in OpenGL coordinates.

source

EllipticalRing

Mousetrap.EllipticalRingFunction
EllipticalRing(center::Vector2f, outer_x_radius::Number, outer_y_radius::Number, x_thickness::Number, y_thickness::Number, n_outer_vertices::Unsigned) -> Shape

Create a shape as an elliptical ring, where

  • center: center of the ring
  • outer_x_radius: distance between the center and the outer perimeter along the x-axis
  • outer_y_radius: distance between the center and the outer perimeter along the y-axis
  • x_thickness: distance between the outer and inner perimeter along the x-axis
  • y_thickness`: distance between the outer and inner perimeter along the y-axis

In OpenGL coordinates.

source

Line

Mousetrap.LineFunction
Line(a::Vector2f, b::Vector2f) -> Shape

Create a shape as a 1-fragment thick line between two points, in OpenGL coordinates.

source

LineStrip

Mousetrap.LineStripFunction
LineStrip(points::Vector{Vector2f}) -> Shape

Create a shape as a line-strip. For points {a1, a2, ..., an}, this will be a set of connected lines {a1, a2}, {a2, a3}, ..., {an-1, an}, in OpenGL coordinates.

source

Lines

Mousetrap.LinesFunction
Lines(::Vector{Pair{Vector2f, Vector2f}) -> Shape

Create a shape as a set of unconnected lines, vertex positions in OpenGL coordinates.

source

Outline

Point

Mousetrap.PointFunction
Point(position::Vector2f) -> Shape

Create a shape as 1-fragment point, in OpenGL coordinates.

source

Points

Mousetrap.PointsFunction
Point(positions::Vector{Vector2f}) -> Shape

Create a shape as a set of unconnected points, in OpenGL coordinates.

source

Polygon

Mousetrap.PolygonFunction
Polygon(points::Vector{Vector2f}) -> Shape

Create a shape as a convex polygon, the outer hull of points will be computed, but no vertex elimination will take place. In OpenGL coordiantes.

source

Rectangle

Mousetrap.RectangleFunction
Rectangle(top_left::Vector2f, size::Vector2f) -> Shape

Create a shape as an axis-aligned rectangle, in OpenGL coordinates.

source

RectangularFrame

Mousetrap.RectangularFrameFunction
RectangularFrame(top_left::Vector2f, outer_size::Vector2f, x_width::Number, y_width::Number) -> Shape

Create a shape as a rectangular frame, where x_width, y_width are the "thickness" of the frames filled area. In OpenGL coordinates.

source

Triangle

Mousetrap.TriangleFunction
Triangle(a::Vector2f, b::Vector2f, c::Vector2f) -> Shape

Create a shape as a triangle defined by three points, in OpenGL coordinates.

source

Wireframe

Mousetrap.WireframeFunction
Wireframe(points::Vector{Vector2f}) -> Shape

Create a shape as a wire-frame. For points {a1, a2, a3, ..., an}, the shape will be a connected series of lines {a1, a2}, {a2, a3}, ..., {an-1, an}, {an, a1}. In OpenGL coordinates.

source

activate!

Mousetrap.activate!Function
activate!(::Widget)

If the widget is activatable, trigger it. Depending on the widget, this may not necssarily emit signal activate. Use emit_signal_activate to manually emit the signal instead.


activate!(::Action) 

Trigger the action's callback. This will also emit signal activated.

source

add_action!

Mousetrap.add_action!Function
add_action!(app::Application, action::Action)

Register an action with the application. This is usually done automatically.


add_action!(model::MenuModel, label::String, action::Action) 

Add an "action"-type item to the menu model


add_action!(shortcut_controller::ShortcutEventController, action::Action) 

Register an action with the shortcut controller. Once connected to a widget, the controller will listen for keyboard events associated with any registered action, triggering that action when the shortcut is recognized.

source

add_allow_all_supported_image_formats!

add_allowed_mime_type!

Mousetrap.add_allowed_mime_type!Function
add_allowed_mime_type!(::FileFilter, mime_type_id::String) 

Let all files pass through the filter whose MIME type is equal to the given string.

source

add_allowed_pattern!

Mousetrap.add_allowed_pattern!Function
add_allowed_pattern!(::FileFilter, pattern::String) 

Let all files pass through the filter whose name match the given shell-style glob.

Example

filter = FilterFilter("pass_julia_files")
add_allowed_pattern!(filter, "*.jl")
source

add_allowed_suffix!

Mousetrap.add_allowed_suffix!Function
add_allowed_suffix!(::FileFilter, suffix::String) 

Let all files pass through the filter whose file extension equal the given string, where suffix should not contain a dot.

Example

filter = FilterFilter("pass_julia_files")
add_allowed_suffix!(filter, "jl") # "jl", not ".jl"

````

source

add_button!

Mousetrap.add_button!Function
add_button!(::AlertDialog, label::String) -> Integer

Add a new button to the dialog. If the button is clicked, the dialog closes automatically. The return value of this function is the buttons ID, which should be stored to later reference the button.

source

add_child!

Mousetrap.add_child!Function
add_child!(stack::Stack, ::Widget, title::String) 

Add a new stack page that will be uniquely identified by title.


add_child!(fixed::Fixed, ::Widget, position::Vector2f) 

Add a widget at given position, in absolute widget-space coordinates.

source

add_controller!

Mousetrap.add_controller!Function
add_controller!(::Widget, controller::EventController) 

Add an event controller to the widget. Once that widget is realized, the controller will start listening for events.

source

add_css!

Mousetrap.add_css!Function
add_css!(code::String) -> Cvoid

Execute CSS code and add it to the global style manager. If compied successfuly, any class defined will be available to be applied to a widget using add_css_class!.

Example

mousetrap.add_css!("""
.custom {
    color: green;
    border-radius: 10%;
}
""")
add_css_class!(window, ".custom")
source

add_css_class!

Mousetrap.add_css_class!Function
add_css_class!(::Widget, class::String)

Apply a custom style class to the widget. Use add_css! to define a CSS class.

Example

mousetrap.add_css!("""
.custom {
    color: green;
    border-radius: 10%;
}
""")
add_css_class!(window, ".custom")
source

add_filter!

add_icon!

Mousetrap.add_icon!Function
add_icon!(model::MenuModel, icon::Icon, action::Action) 

Add an "icon"-type item to the menu model.

source

add_mark!

Mousetrap.add_mark!Function
add_mark!(::Scale, value::Number, position::RelativePosition, [label::String])

Add a mark with an option label. position determines where the mark is shown relative to the scales center.

source

add_marker!

Mousetrap.add_marker!Function
add_marker!(::LevelBar, name::String, value::AbstractFloat) 

Add a marker with label to the level bar.

source

add_overlay!

Mousetrap.add_overlay!Function
add_overlay!(overlay::Overlay, child::Widget ; [include_in_measurement::Bool = true, clip::Bool = false]) 

Add an additional overlay widget. It will be display "on top" of previously added widgets.

If include_in_measurement is true, the overlaid widget will be included in size allocation of the entire Overlay.

If clip is true, if part of a widget goes outside the overlays allocated area, it will be truncated.

source

add_render_task!

Mousetrap.add_render_task!Function
add_render_task!(area::RenderArea, task::RenderTask) 

Register a new render task with the area. Unless a custom handle was connected to the RenderArea using connect_signal_render!, the render task will be drawn every frame.

source

add_resource_path!

add_section!

Mousetrap.add_section!Function
add_section!(self::MenuModel, title::String, to_add::MenuModel, [::SectionFormat]) 

Add a "section"-type menu item to the model, which will be constructed based on to_add.

source

add_shortcut!

add_submenu!

Mousetrap.add_submenu!Function
add_submenu!(model::MenuModel, label::String, to_add::MenuModel) 

Add a "submenu"-type menu item to the model, which will be constructed based on to_add.

source

add_widget!

Mousetrap.add_widget!Function
add_widget!(model::MenuModel, ::Widget) 

Add a "widget"-type item to the model. This widget should be interactable.

source

alt_pressed

Mousetrap.alt_pressedFunction
alt_pressed(::ModifierState) -> Bool

Check if modifier state indicates that the Alt key is currently pressed.

source

apply_to

Mousetrap.apply_toFunction
apply_to(::GLTransform, ::Vector2f) -> Vector2f
apply_to(::GLTransform, ::Vector3f) -> Vector3f

Apply transform to a vector, both operate in OpenGL coordinates.

source

as_circle!

Mousetrap.as_circle!Function
as_circle!(::Shape, center::Vector2f, radius::Number, n_outer_vertices::Integer) 

Create a shape as a circle, defined by its center and radius. In OpenGL coordinates.

source

as_circular_ring!

Mousetrap.as_circular_ring!Function
as_circular_ring!(::Shape, center::Vector2f, outer_radius::Number, thickness::Number, n_outer_vertices::Integer) 

Create a shape as a circular ring, defined by its center, outer_radius, which is the distance to the out perimeter, and thickness which is the distance between the inner and out perimeter.

source

as_cropped

Mousetrap.as_croppedFunction
as_cropped(image::Image, offset_x::Signed, offset_y::Signed, new_width::Integer, new_height::Integer) -> Image

Crop the image, this is similar to the "resize canvas" operation in many image manipulation programs. offset_x and offset_y is the offset between the top-left pixel of the image and the top-left pixel of the newly allocated area, where an offset of 0 means the new image is anchored at the same pixel as the original. Offsets can be negative.

This function does not modify the original image.

source

as_degrees

as_ellipse!

Mousetrap.as_ellipse!Function
as_ellipse!(::Shape, center::Vector2f, x_radius::Number, y_radius::Number, n_outer_vertices::Integer) 

Create a shape as an ellipse, defined by its center and radii along the x- and y-dimension, in OpenGL coordinates.

source

as_elliptical_ring!

Mousetrap.as_elliptical_ring!Function
as_elliptical_ring!(::Shape, center::Vector2f, outer_x_radius::Number, outer_y_radius::Number, x_thickness::Number, y_thickness::Number, n_outer_vertices::Unsigned) 

Create a shape as an elliptical ring, where

  • center: center of the ring
  • outer_x_radius: distance between the center and the outer perimeter along the x-axis
  • outer_y_radius: distance between the center and the outer perimeter along the y-axis
  • x_thickness: distance between the outer and inner perimeter along the x-axis
  • y_thickness`: distance between the outer and inner perimeter along the y-axis

In OpenGL coordinates.

source

as_flipped

Mousetrap.as_flippedFunction
as_flipped(::Image, flip_horizontally::Bool, flip_vertically::Bool) -> Image

Create a new image that is a horizontally and/or vertically mirrored.

This function does not modify the original image.

source

as_line!

Mousetrap.as_line!Function
as_line!(::Shape, a::Vector2f, b::Vector2f) 

Create a shape as a 1-fragment thick line between two points, in OpenGL coordinates.

source

as_line_strip!

Mousetrap.as_line_strip!Function
as_line_strip!(::Shape, points::Vector{Vector2f}) 

Create a shape as a line-strip. For points {a1, a2, ..., an}, this will be a set of connected lines {a1, a2}, {a2, a3}, ..., {an-1, an}, in OpenGL coordinates.

source

as_lines!

Mousetrap.as_lines!Function
as_lines!(::Shape, points::Vector{Pair{Vector2f, Vector2f}}) 

Create a shape as a set of unconnected lines, vertex positions in OpenGL coordinates.

source

as_microseconds

as_milliseconds

as_minutes

as_nanoseconds

as_outline!

as_point!

Mousetrap.as_point!Function
as_point!(::Shape, position::Vector2f) 

Create a shape as 1-fragment point, in OpenGL coordinates.

source

as_points!

Mousetrap.as_points!Function
as_points!(::Shape, positions::Vector{Vector2f}) 

Create a shape as a set of unconnected points, in OpenGL coordinates.

source

as_polygon!

Mousetrap.as_polygon!Function
as_polygon!(::Shape, points::Vector{Vector2f}) 

Create a shape as a convex polygon, the outer hull of points will be computed, but no vertex elimination will take place. In OpenGL coordiantes.

source

as_radians

as_rectangle!

Mousetrap.as_rectangle!Function
as_rectangle!(::Shape, top_left::Vector2f, size::Vector2f) 

Create a shape as an axis-aligned rectangle, in OpenGL coordinates.

source

as_rectangular_frame!

Mousetrap.as_rectangular_frame!Function
as_rectangular_frame!(::Shape, top_left::Vector2f, outer_size::Vector2f, x_width::Number, y_width::Number) 

Create a shape as a rectangular frame, where x_width, y_width are the "thickness" of the frames filled area. In OpenGL coordinates.

source

as_scaled

Mousetrap.as_scaledFunction
as_scaled(::Image, size_x::Integer, size_y::Integer, ::InterpolationType) -> Image

Scale the image to a new size. This is similar to the "scale image" option in many image manipulation programs.

Note that this does not modify the original image.

source

as_seconds

as_string

as_triangle!

Mousetrap.as_triangle!Function
as_triangle!(::Shape, a::Vector2f, b::Vector2f, c::Vector2f) 

Create a shape as a triangle defined by three points, in OpenGL coordinates.

source

as_wireframe!

Mousetrap.as_wireframe!Function
as_wireframe!(::Shape, points::Vector{Vector2f}) 

Create a shape as a wire-frame. For points {a1, a2, a3, ..., an}, the shape will be a connected series of lines {a1, a2}, {a2, a3}, ..., {an-1, an}, {an, a1}. In OpenGL coordinates.

source

bind

Mousetrap.bindFunction
bind(::TextureObject) 

Bind a texture for rendering, which will make it available at GL_TEXTURE_UNIT_0. This is usually done automatically when a texture was registered with a shape using set_texture!.

source

bind_as_render_target

Mousetrap.bind_as_render_targetFunction
bind_as_render_target(render_texture::RenderTexture) 

Bind a render texture as the current frame buffer. This should be done inside the signal handler of RenderArea's signal render.

Use unbind_as_render_target to restore the previously bound frame buffer.

source

calculate_monitor_dpi

Mousetrap.calculate_monitor_dpiFunction
calculate_monitor_dpi(::Widget) -> Float32

Calculate the dpi (dots per inch) of the monitor that is currently displaying the widgets associated window.

source

cancel!

Mousetrap.cancel!Function
cancel!(::FileChooser)

Cancel the file chooser, this will behave identically to the user clicking the cancel button.


cancel!(::FileMonitor) 

Cancel the file monitor. It will no longer monitor the file.

source

clear

Mousetrap.clearFunction
clear(::RenderArea) 

Clear the current framebuffer, this will reset GL_COLOR_BUFFER_BIT and replace the contents of the currently bound framebuffer with RGBA(0, 0, 0, 0).

source

clear!

Mousetrap.clear!Function
clear!(::Box) 
clear!(::FlowBox)
clear!(::ImageDisplay) 
clear!(::ListView) 
clear!(::ListView, [iterator::ListViewIterator]) 
clear!(::GridView) 

Remove all children from the widget.

source

clear_filters!

clear_marks!

clear_render_tasks!

clear_shortcuts!

close!

Mousetrap.close!Function
close!(::Window) 

Attempt to close the window, this will emit signal close_request.

source

combine_with

Mousetrap.combine_withFunction
combine_with(self::GLTransform, other::GLTransform) -> GLTransform

Perform matrix-multiplication and return the resulting transform, in OpenGL coordinates.

source

connect_signal_activate!

Mousetrap.connect_signal_activate!Function
connect_signal_activate!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal activate, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_activate_default_widget!

Mousetrap.connect_signal_activate_default_widget!Function
connect_signal_activate_default_widget!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal activate_default_widget, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_activate_focused_widget!

Mousetrap.connect_signal_activate_focused_widget!Function
connect_signal_activate_focused_widget!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal activate_focused_widget, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_activate_item!

Mousetrap.connect_signal_activate_item!Function
connect_signal_activate_item!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal activate_item, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, index::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_activated!

Mousetrap.connect_signal_activated!Function
connect_signal_activated!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal activated, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_button_clicked!

Mousetrap.connect_signal_button_clicked!Function
connect_signal_button_clicked!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal button_clicked, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_click_pressed!

Mousetrap.connect_signal_click_pressed!Function
connect_signal_click_pressed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal click_pressed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, n_presses::Integer, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_click_released!

Mousetrap.connect_signal_click_released!Function
connect_signal_click_released!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal click_released, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, n_presses::Integer, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_click_stopped!

Mousetrap.connect_signal_click_stopped!Function
connect_signal_click_stopped!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal click_stopped, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_clicked!

Mousetrap.connect_signal_clicked!Function
connect_signal_clicked!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal clicked, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_close_request!

Mousetrap.connect_signal_close_request!Function
connect_signal_close_request!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal close_request, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> WindowCloseRequestResult

Where T is the type of the signal emitter instance.

source

connect_signal_closed!

Mousetrap.connect_signal_closed!Function
connect_signal_closed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal closed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_destroy!

Mousetrap.connect_signal_destroy!Function
connect_signal_destroy!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal destroy, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_dismissed!

Mousetrap.connect_signal_dismissed!Function
connect_signal_dismissed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal dismissed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_drag!

Mousetrap.connect_signal_drag!Function
connect_signal_drag!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal drag, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x_offset::AbstractFloat, y_offset::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_drag_begin!

Mousetrap.connect_signal_drag_begin!Function
connect_signal_drag_begin!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal drag_begin, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, start_x::AbstractFloat, start_y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_drag_end!

Mousetrap.connect_signal_drag_end!Function
connect_signal_drag_end!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal drag_end, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x_offset::AbstractFloat, y_offset::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_focus_gained!

Mousetrap.connect_signal_focus_gained!Function
connect_signal_focus_gained!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal focus_gained, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_focus_lost!

Mousetrap.connect_signal_focus_lost!Function
connect_signal_focus_lost!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal focus_lost, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_hide!

Mousetrap.connect_signal_hide!Function
connect_signal_hide!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal hide, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_items_changed!

Mousetrap.connect_signal_items_changed!Function
connect_signal_items_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal items_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, position::Integer, n_removed::Integer, n_added::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_key_pressed!

Mousetrap.connect_signal_key_pressed!Function
connect_signal_key_pressed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal key_pressed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, code::KeyCode, modifiers::ModifierState, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_key_released!

Mousetrap.connect_signal_key_released!Function
connect_signal_key_released!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal key_released, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, code::KeyCode, modifiers::ModifierState, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_kinetic_scroll_decelerate!

Mousetrap.connect_signal_kinetic_scroll_decelerate!Function
connect_signal_kinetic_scroll_decelerate!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal kinetic_scroll_decelerate, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x_velocity::AbstractFloat, y_velocity::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_map!

Mousetrap.connect_signal_map!Function
connect_signal_map!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal map, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_modifiers_changed!

Mousetrap.connect_signal_modifiers_changed!Function
connect_signal_modifiers_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal modifiers_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, modifiers::ModifierState, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_motion!

Mousetrap.connect_signal_motion!Function
connect_signal_motion!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal motion, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_motion_enter!

Mousetrap.connect_signal_motion_enter!Function
connect_signal_motion_enter!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal motion_enter, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_motion_leave!

Mousetrap.connect_signal_motion_leave!Function
connect_signal_motion_leave!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal motion_leave, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_page_added!

Mousetrap.connect_signal_page_added!Function
connect_signal_page_added!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal page_added, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, page_index::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_page_removed!

Mousetrap.connect_signal_page_removed!Function
connect_signal_page_removed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal page_removed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, page_index::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_page_reordered!

Mousetrap.connect_signal_page_reordered!Function
connect_signal_page_reordered!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal page_reordered, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, page_index::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_page_selection_changed!

Mousetrap.connect_signal_page_selection_changed!Function
connect_signal_page_selection_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal page_selection_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, page_index::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_paint!

Mousetrap.connect_signal_paint!Function
connect_signal_paint!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal paint, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_pan!

Mousetrap.connect_signal_pan!Function
connect_signal_pan!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal pan, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, ::PanDirection, offset::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_press_cancelled!

Mousetrap.connect_signal_press_cancelled!Function
connect_signal_press_cancelled!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal press_cancelled, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_pressed!

Mousetrap.connect_signal_pressed!Function
connect_signal_pressed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal pressed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_properties_changed!

Mousetrap.connect_signal_properties_changed!Function
connect_signal_properties_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal properties_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_proximity!

Mousetrap.connect_signal_proximity!Function
connect_signal_proximity!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal proximity, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_realize!

Mousetrap.connect_signal_realize!Function
connect_signal_realize!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal realize, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_render!

Mousetrap.connect_signal_render!Function
connect_signal_render!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal render, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, gdk_gl_context::Ptr{Cvoid}, [::Data_t]) -> Bool

Where T is the type of the signal emitter instance.

source

connect_signal_resize!

Mousetrap.connect_signal_resize!Function
connect_signal_resize!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal resize, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, width::Integer, height::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_revealed!

Mousetrap.connect_signal_revealed!Function
connect_signal_revealed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal revealed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_rotation_changed!

Mousetrap.connect_signal_rotation_changed!Function
connect_signal_rotation_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal rotation_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, angle_absolute::AbstractFloat, angle_delta::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_scale_changed!

Mousetrap.connect_signal_scale_changed!Function
connect_signal_scale_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal scale_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, scale::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_scroll!

Mousetrap.connect_signal_scroll!Function
connect_signal_scroll!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal scroll, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x_delta::AbstractFloat, y_delta::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_scroll_begin!

Mousetrap.connect_signal_scroll_begin!Function
connect_signal_scroll_begin!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal scroll_begin, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_scroll_child!

Mousetrap.connect_signal_scroll_child!Function
connect_signal_scroll_child!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal scroll_child, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, scroll_type::ScrollType, is_horizontal::Bool, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_scroll_end!

Mousetrap.connect_signal_scroll_end!Function
connect_signal_scroll_end!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal scroll_end, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_selection_changed!

Mousetrap.connect_signal_selection_changed!Function
connect_signal_selection_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal selection_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, position::Integer, n_items::Integer, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_show!

Mousetrap.connect_signal_show!Function
connect_signal_show!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal show, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_shutdown!

Mousetrap.connect_signal_shutdown!Function
connect_signal_shutdown!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal shutdown, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_stylus_down!

Mousetrap.connect_signal_stylus_down!Function
connect_signal_stylus_down!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal stylus_down, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_stylus_up!

Mousetrap.connect_signal_stylus_up!Function
connect_signal_stylus_up!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal stylus_up, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x::AbstractFloat, y::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_swipe!

Mousetrap.connect_signal_swipe!Function
connect_signal_swipe!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal swipe, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, x_velocity::AbstractFloat, y_velocity::AbstractFloat, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_switched!

Mousetrap.connect_signal_switched!Function
connect_signal_switched!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal switched, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_text_changed!

Mousetrap.connect_signal_text_changed!Function
connect_signal_text_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal text_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_toggled!

Mousetrap.connect_signal_toggled!Function
connect_signal_toggled!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal toggled, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_unmap!

Mousetrap.connect_signal_unmap!Function
connect_signal_unmap!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal unmap, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_unrealize!

Mousetrap.connect_signal_unrealize!Function
connect_signal_unrealize!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal unrealize, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_update!

Mousetrap.connect_signal_update!Function
connect_signal_update!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal update, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_value_changed!

Mousetrap.connect_signal_value_changed!Function
connect_signal_value_changed!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal value_changed, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

connect_signal_wrapped!

Mousetrap.connect_signal_wrapped!Function
connect_signal_wrapped!(f, ::T, [::Data_t]) -> Cvoid

Connect to signal wrapped, where T is a signal emitter instance that supports this signal

Data_t is an optional argument, which, if specified, will be forwarded to the signal handler.

f is required to be invocable as a function with signature:

(::T, [::Data_t]) -> Nothing

Where T is the type of the signal emitter instance.

source

contains_file

contains_image

contains_string

control_pressed

Mousetrap.control_pressedFunction
control_pressed(modifier_state::ModifierState) -> Bool

Check whether the modifier state indicates that Control is currently pressed.

source

copy!

Mousetrap.copy!Function
copy!(from::FileDescriptor, to::FileDescriptor, allow_overwrite::Bool ; make_backup::Bool = false, follow_symlink::Bool = false) -> Bool

Copy a file from one location to another. Returns true if the operation was successful.

source

create!

Mousetrap.create!Function
create!(::Image, width::Integer, height::Integer, [color::RGBA]) 
create!(::TextureObject, width::Integer, height::Integer) 

Clear the current pixeldata and reinitialize it at given size. Will fille each pixel with RGBA(0, 0, 0, 0), unless otherwise specified.

source

create_as_file_preview!

Mousetrap.create_as_file_preview!Function
create_as_file_preview!(image_display::ImageDisplay, file::FileDescriptor) 

If the file points to an image file, create as a preview for that image, otherwise create from the files default icon.

source

create_directory_at!

Mousetrap.create_directory_at!Function
create_directory_at!(destination::FileDescriptor) -> Bool

Create folder at given location, returns true if the operation was successful.

source

create_file_at!

Mousetrap.create_file_at!Function
create_file_at!(destination::FileDescriptor, should_replace::Bool) -> Bool

Create file at given location, returns true if the operation was successful

source

create_from_file!

Mousetrap.create_from_file!Function
create_from_file!(::Icon, path::String) -> Bool
create_from_file!(::Image, path::String) -> Bool
create_from_file!(::ImageDisplay, path::String) -> Bool
create_from_file!(::KeyFile, path::String) -> Bool
create_from_file!(::Shader, type::ShaderType, file::String) -> Bool 

Initialize the object from a file. Returns true if the operation was successful.

source

create_from_icon!

create_from_image!

Mousetrap.create_from_image!Function
create_from_image!(::TextureObject, ::Image) 
create_from_image!(::ImageDisplay, ::Image) 

Initialize from an image. This will replace the current pixel data and size.

source

create_from_path!

Mousetrap.create_from_path!Function
create_from_path!(::FileDescriptor, path::String) 

Create as file descriptor pointing to given path. Use exists to check if this location is valid and contains a file or folde.

source

create_from_string!

Mousetrap.create_from_string!Function
create_from_string!(::KeyFile, file::String) 

De-serialize from a string. If you are loading a KeyFile from a file on disk, create_from_file! should be preferred.


create_from_string!(::Shader, type::ShaderType, glsl_code::String) 

Create from GLSL code. See the manual chapter on native rendering for more information.

source

create_from_theme!

Mousetrap.create_from_theme!Function
create_from_theme!(::Icon, theme::IconTheme, id::String, square_resolution::Integer, [scale::Integer = 1]) 

Create an icon from the icon theme.

source

create_from_uri!

Mousetrap.create_from_uri!Function
create_from_uri!(::FileDescriptor, uri::String) 

Create as file descriptor pointing to given URI. There is no guarantee that the location exists or points to a valid file or folder.

source

create_monitor

Mousetrap.create_monitorFunction
create_monitor(descriptor::FileDescriptor) -> FileMonitor

Create a FileMonitor monitoring the current file or folder. This may fail if the location does not contain a valid file.

source

degrees

Mousetrap.degreesFunction
degrees(::Number) -> Angle

Create angle from degrees, automatically clamped to [0°, 360°].

source

delete_at!

Mousetrap.delete_at!Function
delete_at!(::FileDescriptor) -> Bool

Irreversibly delete file at given location, returns true if the operation was successful.

source

destroy!

device_axis_to_string

disconnect_signal_activate!

disconnect_signal_activate_default_widget!

disconnect_signal_activate_focused_widget!

disconnect_signal_activate_item!

disconnect_signal_activated!

disconnect_signal_button_clicked!

disconnect_signal_click_pressed!

disconnect_signal_click_released!

disconnect_signal_click_stopped!

disconnect_signal_clicked!

disconnect_signal_close_request!

disconnect_signal_closed!

disconnect_signal_destroy!

disconnect_signal_dismissed!

disconnect_signal_drag!

disconnect_signal_drag_begin!

disconnect_signal_drag_end!

disconnect_signal_focus_gained!

disconnect_signal_focus_lost!

disconnect_signal_hide!

disconnect_signal_items_changed!

disconnect_signal_key_pressed!

disconnect_signal_key_released!

disconnect_signal_kinetic_scroll_decelerate!

disconnect_signal_map!

disconnect_signal_modifiers_changed!

disconnect_signal_motion!

disconnect_signal_motion_enter!

disconnect_signal_motion_leave!

disconnect_signal_page_added!

disconnect_signal_page_removed!

disconnect_signal_page_reordered!

disconnect_signal_page_selection_changed!

disconnect_signal_paint!

disconnect_signal_pan!

disconnect_signal_press_cancelled!

disconnect_signal_pressed!

disconnect_signal_properties_changed!

disconnect_signal_proximity!

disconnect_signal_realize!

disconnect_signal_render!

disconnect_signal_resize!

disconnect_signal_revealed!

disconnect_signal_rotation_changed!

disconnect_signal_scale_changed!

disconnect_signal_scroll!

disconnect_signal_scroll_begin!

disconnect_signal_scroll_child!

disconnect_signal_scroll_end!

disconnect_signal_selection_changed!

disconnect_signal_show!

disconnect_signal_shutdown!

disconnect_signal_stylus_down!

disconnect_signal_stylus_up!

disconnect_signal_swipe!

disconnect_signal_switched!

disconnect_signal_text_changed!

disconnect_signal_toggled!

disconnect_signal_unmap!

disconnect_signal_unrealize!

disconnect_signal_update!

disconnect_signal_value_changed!

disconnect_signal_wrapped!

download

Mousetrap.downloadFunction
download(texture::TextureObject) -> Image

Retrieve the pixel data from the graphics card and return it as an image. This is an extremely costly operation.

source

elapsed

emit_signal_activate

Mousetrap.emit_signal_activateFunction
emit_signal_activate(::T, ) -> Nothing

Manually emit signal activate, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_activate_default_widget

Mousetrap.emit_signal_activate_default_widgetFunction
emit_signal_activate_default_widget(::T, ) -> Nothing

Manually emit signal activate_default_widget, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_activate_focused_widget

Mousetrap.emit_signal_activate_focused_widgetFunction
emit_signal_activate_focused_widget(::T, ) -> Nothing

Manually emit signal activate_focused_widget, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_activate_item

Mousetrap.emit_signal_activate_itemFunction
emit_signal_activate_item(::T, index::Integer) -> Nothing

Manually emit signal activate_item, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_activated

Mousetrap.emit_signal_activatedFunction
emit_signal_activated(::T, ) -> Nothing

Manually emit signal activated, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_button_clicked

Mousetrap.emit_signal_button_clickedFunction
emit_signal_button_clicked(::T, ) -> Nothing

Manually emit signal button_clicked, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_click_pressed

Mousetrap.emit_signal_click_pressedFunction
emit_signal_click_pressed(::T, n_presses::Integer, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal click_pressed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_click_released

Mousetrap.emit_signal_click_releasedFunction
emit_signal_click_released(::T, n_presses::Integer, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal click_released, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_click_stopped

Mousetrap.emit_signal_click_stoppedFunction
emit_signal_click_stopped(::T, ) -> Nothing

Manually emit signal click_stopped, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_clicked

Mousetrap.emit_signal_clickedFunction
emit_signal_clicked(::T, ) -> Nothing

Manually emit signal clicked, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_close_request

Mousetrap.emit_signal_close_requestFunction
emit_signal_close_request(::T, ) -> WindowCloseRequestResult

Manually emit signal close_request, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_closed

Mousetrap.emit_signal_closedFunction
emit_signal_closed(::T, ) -> Nothing

Manually emit signal closed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_destroy

Mousetrap.emit_signal_destroyFunction
emit_signal_destroy(::T, ) -> Nothing

Manually emit signal destroy, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_dismissed

Mousetrap.emit_signal_dismissedFunction
emit_signal_dismissed(::T, ) -> Nothing

Manually emit signal dismissed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_drag

Mousetrap.emit_signal_dragFunction
emit_signal_drag(::T, x_offset::AbstractFloat, y_offset::AbstractFloat) -> Nothing

Manually emit signal drag, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_drag_begin

Mousetrap.emit_signal_drag_beginFunction
emit_signal_drag_begin(::T, start_x::AbstractFloat, start_y::AbstractFloat) -> Nothing

Manually emit signal drag_begin, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_drag_end

Mousetrap.emit_signal_drag_endFunction
emit_signal_drag_end(::T, x_offset::AbstractFloat, y_offset::AbstractFloat) -> Nothing

Manually emit signal drag_end, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_focus_gained

Mousetrap.emit_signal_focus_gainedFunction
emit_signal_focus_gained(::T, ) -> Nothing

Manually emit signal focus_gained, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_focus_lost

Mousetrap.emit_signal_focus_lostFunction
emit_signal_focus_lost(::T, ) -> Nothing

Manually emit signal focus_lost, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_hide

Mousetrap.emit_signal_hideFunction
emit_signal_hide(::T, ) -> Nothing

Manually emit signal hide, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_items_changed

Mousetrap.emit_signal_items_changedFunction
emit_signal_items_changed(::T, position::Integer, n_removed::Integer, n_added::Integer) -> Nothing

Manually emit signal items_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_key_pressed

Mousetrap.emit_signal_key_pressedFunction
emit_signal_key_pressed(::T, code::KeyCode, modifiers::ModifierState) -> Nothing

Manually emit signal key_pressed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_key_released

Mousetrap.emit_signal_key_releasedFunction
emit_signal_key_released(::T, code::KeyCode, modifiers::ModifierState) -> Nothing

Manually emit signal key_released, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_kinetic_scroll_decelerate

Mousetrap.emit_signal_kinetic_scroll_decelerateFunction
emit_signal_kinetic_scroll_decelerate(::T, x_velocity::AbstractFloat, y_velocity::AbstractFloat) -> Nothing

Manually emit signal kinetic_scroll_decelerate, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_map

Mousetrap.emit_signal_mapFunction
emit_signal_map(::T, ) -> Nothing

Manually emit signal map, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_modifiers_changed

Mousetrap.emit_signal_modifiers_changedFunction
emit_signal_modifiers_changed(::T, modifiers::ModifierState) -> Nothing

Manually emit signal modifiers_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_motion

Mousetrap.emit_signal_motionFunction
emit_signal_motion(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal motion, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_motion_enter

Mousetrap.emit_signal_motion_enterFunction
emit_signal_motion_enter(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal motion_enter, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_motion_leave

Mousetrap.emit_signal_motion_leaveFunction
emit_signal_motion_leave(::T, ) -> Nothing

Manually emit signal motion_leave, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_page_added

Mousetrap.emit_signal_page_addedFunction
emit_signal_page_added(::T, page_index::Integer) -> Nothing

Manually emit signal page_added, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_page_removed

Mousetrap.emit_signal_page_removedFunction
emit_signal_page_removed(::T, page_index::Integer) -> Nothing

Manually emit signal page_removed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_page_reordered

Mousetrap.emit_signal_page_reorderedFunction
emit_signal_page_reordered(::T, page_index::Integer) -> Nothing

Manually emit signal page_reordered, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_page_selection_changed

Mousetrap.emit_signal_page_selection_changedFunction
emit_signal_page_selection_changed(::T, page_index::Integer) -> Nothing

Manually emit signal page_selection_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_paint

Mousetrap.emit_signal_paintFunction
emit_signal_paint(::T, ) -> Nothing

Manually emit signal paint, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_pan

Mousetrap.emit_signal_panFunction
emit_signal_pan(::T, ::PanDirection, offset::AbstractFloat) -> Nothing

Manually emit signal pan, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_press_cancelled

Mousetrap.emit_signal_press_cancelledFunction
emit_signal_press_cancelled(::T, ) -> Nothing

Manually emit signal press_cancelled, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_pressed

Mousetrap.emit_signal_pressedFunction
emit_signal_pressed(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal pressed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_properties_changed

Mousetrap.emit_signal_properties_changedFunction
emit_signal_properties_changed(::T, ) -> Nothing

Manually emit signal properties_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_proximity

Mousetrap.emit_signal_proximityFunction
emit_signal_proximity(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal proximity, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_realize

Mousetrap.emit_signal_realizeFunction
emit_signal_realize(::T, ) -> Nothing

Manually emit signal realize, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_render

Mousetrap.emit_signal_renderFunction
emit_signal_render(::T, gdk_gl_context::Ptr{Cvoid}) -> Bool

Manually emit signal render, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_resize

Mousetrap.emit_signal_resizeFunction
emit_signal_resize(::T, width::Integer, height::Integer) -> Nothing

Manually emit signal resize, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_revealed

Mousetrap.emit_signal_revealedFunction
emit_signal_revealed(::T, ) -> Nothing

Manually emit signal revealed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_rotation_changed

Mousetrap.emit_signal_rotation_changedFunction
emit_signal_rotation_changed(::T, angle_absolute::AbstractFloat, angle_delta::AbstractFloat) -> Nothing

Manually emit signal rotation_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_scale_changed

Mousetrap.emit_signal_scale_changedFunction
emit_signal_scale_changed(::T, scale::AbstractFloat) -> Nothing

Manually emit signal scale_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_scroll

Mousetrap.emit_signal_scrollFunction
emit_signal_scroll(::T, x_delta::AbstractFloat, y_delta::AbstractFloat) -> Nothing

Manually emit signal scroll, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_scroll_begin

Mousetrap.emit_signal_scroll_beginFunction
emit_signal_scroll_begin(::T, ) -> Nothing

Manually emit signal scroll_begin, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_scroll_child

Mousetrap.emit_signal_scroll_childFunction
emit_signal_scroll_child(::T, scroll_type::ScrollType, is_horizontal::Bool) -> Nothing

Manually emit signal scroll_child, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_scroll_end

Mousetrap.emit_signal_scroll_endFunction
emit_signal_scroll_end(::T, ) -> Nothing

Manually emit signal scroll_end, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_selection_changed

Mousetrap.emit_signal_selection_changedFunction
emit_signal_selection_changed(::T, position::Integer, n_items::Integer) -> Nothing

Manually emit signal selection_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_show

Mousetrap.emit_signal_showFunction
emit_signal_show(::T, ) -> Nothing

Manually emit signal show, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_shutdown

Mousetrap.emit_signal_shutdownFunction
emit_signal_shutdown(::T, ) -> Nothing

Manually emit signal shutdown, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_stylus_down

Mousetrap.emit_signal_stylus_downFunction
emit_signal_stylus_down(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal stylus_down, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_stylus_up

Mousetrap.emit_signal_stylus_upFunction
emit_signal_stylus_up(::T, x::AbstractFloat, y::AbstractFloat) -> Nothing

Manually emit signal stylus_up, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_swipe

Mousetrap.emit_signal_swipeFunction
emit_signal_swipe(::T, x_velocity::AbstractFloat, y_velocity::AbstractFloat) -> Nothing

Manually emit signal swipe, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_switched

Mousetrap.emit_signal_switchedFunction
emit_signal_switched(::T, ) -> Nothing

Manually emit signal switched, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_text_changed

Mousetrap.emit_signal_text_changedFunction
emit_signal_text_changed(::T, ) -> Nothing

Manually emit signal text_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_toggled

Mousetrap.emit_signal_toggledFunction
emit_signal_toggled(::T, ) -> Nothing

Manually emit signal toggled, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_unmap

Mousetrap.emit_signal_unmapFunction
emit_signal_unmap(::T, ) -> Nothing

Manually emit signal unmap, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_unrealize

Mousetrap.emit_signal_unrealizeFunction
emit_signal_unrealize(::T, ) -> Nothing

Manually emit signal unrealize, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_update

Mousetrap.emit_signal_updateFunction
emit_signal_update(::T, ) -> Nothing

Manually emit signal update, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_value_changed

Mousetrap.emit_signal_value_changedFunction
emit_signal_value_changed(::T, ) -> Nothing

Manually emit signal value_changed, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

emit_signal_wrapped

Mousetrap.emit_signal_wrappedFunction
emit_signal_wrapped(::T, ) -> Nothing

Manually emit signal wrapped, where T is a signal emitter that supports this signal. The arguments will forwarded to the signal handler.

source

exists

Mousetrap.existsFunction
exists(::FileDescriptor) -> Bool

Check if file location contains a valid file or folder.

source

find

Mousetrap.findFunction
find(::ListView, ::Widget, [::ListViewIterator]) -> Signed
find(::GridView, ::Widget) -> Signed

Get index of widget in view, or -1 if widget is not part of view.

source

flush

Mousetrap.flushFunction
flush(::RenderArea) -> Cvoid

Equivalent to glFlush, requests for the bound framebuffer to be pushed to the screen. This may not immediately update the RenderArea.

source

from_gl_coordinates

Mousetrap.from_gl_coordinatesFunction
from_gl_coordinates(area::RenderArea, gl_coordinates::Vector2f) -> Vector2f

Convert OpenGL coordinates to absolute widget-space coordinates. This will take into account the RenderAreas currently allocated size on screen.

source

get_acceleration_rate

Mousetrap.get_acceleration_rateFunction
get_acceleration_rate(::SpinButton) -> Float64

Get the current rate at which the spin button accelerates when one of the buttons is held down.

source

get_accept_label

get_action

Mousetrap.get_actionFunction
get_action(app::Application, id::String) -> Action

Retrieve an action registered with the application.

source

get_adjustment

Mousetrap.get_adjustmentFunction
get_adjustment(::Scale) -> Adjustment
get_adjustment(::SpinButton) -> Adjustment
get_adjustment(::Scrollbar) -> Adjustment

Retrieve the adjustment of the widget. Modifying the adjustment will modify the widget, and vice-versa.

source

get_allocated_size

Mousetrap.get_allocated_sizeFunction
get_allocated_size(::Widget) -> Vector2f

Get the size the widget currently occupies on screen, in pixels. If the widget is not currently shown, this function will return (0, 0).

source

get_allow_only_numeric

get_always_show_arrow

Mousetrap.get_always_show_arrowFunction
get_always_show_arrow(::DropDown) -> Bool
get_always_show_arrow(::PopoverButton) -> Bool

Get whether an arrow should be drawn next to the label.

source

get_angle_delta

Mousetrap.get_angle_deltaFunction
get_angle_delta(::RotateEventController) -> Angle

Get the difference between the current angle and the angle recognized when the gesture started.

source

get_auto_render

get_autohide

Mousetrap.get_autohideFunction
get_autohide(::Popover) -> Bool

Get whether the popover should automatically hide when it looses focus.

source

get_axis_value

Mousetrap.get_axis_valueFunction
get_axis_value(::StylusEventController, ::DeviceAxis) -> Float32

Get value for the devices axis, or 0 if no such axis is present. This value will usually be in [0, 1].

source

get_bottom_margin

Mousetrap.get_bottom_marginFunction
get_bottom_margin(::TextView) -> Float32

Get the distance between the bottom of the text and the bottom of the text views frame.

source

get_bounding_box

Mousetrap.get_bounding_boxFunction
get_bounding_box(::Shape) -> AxisAlignedRectangle

Get the axis-aligned bounding box of the shape. This is the smallest rectangle that contains all vertices, in OpenGL coordinates.

source

get_button_action_id

get_button_label

Mousetrap.get_button_labelFunction
get_button_label!(::AlertDialog, index::Integer) -> String

Get label of the button at given ID, obtained when calling add_button!.

get_button_label!(::PopupMessage) -> String

Get label of the singular button, or "" if no button is present.

source

get_can_respond_to_input

get_centroid

Mousetrap.get_centroidFunction
get_centroid(::Shape) -> Vector2f

Get the centroid of the shape, this is the mathematical average of all its vertices positions, in OpenGL coordinates.

source

get_child_at

Mousetrap.get_child_atFunction
get_child_at(::Stack, index::Integer) -> StackID

Retrieve the ID of the stack page at given position, or "" if the index is out of bounds.

source

get_child_x_alignment

get_child_y_alignment

get_children

Mousetrap.get_childrenFunction
get_children(descriptor::FileDescriptor ; [recursive = false]) -> Vector{FileDescriptor}

Get all children of a folder. If the location pointed to by descriptor is a file or does not exist, the resulting vector will be empty.

source

get_clipboard

Mousetrap.get_clipboardFunction
get_clipboard(::Widget) -> Clipboard

Retrieve the clipboard from a widget, which should usually be the top-level window.

source

get_color

get_column_at

Mousetrap.get_column_atFunction
get_column_at(column_view::ColumnView, index::Integer) -> ColumnViewColumn

Get column at specified position, 1-based.

source

get_column_spacing

get_column_with_title

get_columns_homogeneous

get_comment_above

Mousetrap.get_comment_aboveFunction
get_comment_above(::KeyFile, group::GroupID) -> String
get_comment_above(::KeyFile, group::GroupID, key::KeyID) -> String

Get the singular comment above a group or key declaration.

source

get_content_type

get_css_classes

get_current_button

get_current_offset

Mousetrap.get_current_offsetFunction
get_current_offset(::DragEventController) -> Vecto2f

Get the distance between the current cursor position and the point of origin for the drag-gestured, in absolute widget-space coordinates.

source

get_current_page

get_current_theme

Mousetrap.get_current_themeFunction
get_current_theme(::Application) -> Theme

Get the currently used theme, or THEME_DEFAULT_LIGHT if the application is uninitialized and no theme was chosen yet.

source

get_cursor_visible

get_delay_factor

Mousetrap.get_delay_factorFunction
get_delay_factor(::LongPressEventController) -> Float32

Get multiplier that determines after how much time a long press gesture is recognized, where 1 is no change as compared to the default, 2 is twice as long, 0.5 is half as long.

source

get_destroy_with_parent

get_detailed_description

get_duration

get_editable

get_ellipsize_mode

get_enable_rubberband_selection

Mousetrap.get_enable_rubberband_selectionFunction
get_enable_rubberband_selection(::ListView) -> Bool
get_enable_rubberband_selection(::GridView) -> Bool
get_enable_rubberband_selection(::ColumnView) -> Bool

Get whether the user can select multiple children by click-dragging with the cursor. The selectable widgets selection mode has to be SELECTION_MODE_MULTIPLE in order for this to be possible.

source

get_enabled

Mousetrap.get_enabledFunction
get_enabled(::Action) -> Bool

Get whether the action is enabled. A disabled action cannot be activated and all its connected widgets are disabled.

source

get_end_child_resizable

get_end_child_shrinkable

Mousetrap.get_end_child_shrinkableFunction
get_end_child_shrinkable(::Paned) -> Bool

Get whether the user can resize the end child such that its allocated area inside the paned is smaller than the natural size of the child.

source

get_expand_horizontally

get_expand_vertically

get_file_chooser_action

get_file_extension

Mousetrap.get_file_extensionFunction
get_file_extension(::FileDescriptor) -> String

Get the file extension of the file. This will be any characters after the last ..

source

get_fixed_width

get_focus_on_click

get_focus_visible

Mousetrap.get_focus_visibleFunction
get_focus_visible(::Window) -> Bool

Get whether which widget currently holds input focus should be highlighted using a border.

source

get_fraction

Mousetrap.get_fractionFunction
get_fraction(::ProgressBar) -> Float32

Get the currently displayed fraction of the ProgressBar, in [0, 1].

source

get_fragment_shader_id

get_groups

Mousetrap.get_groupsFunction
get_groups(::KeyFile) -> Vector{GroupID}

Get all group IDs currently present in the key file.

source

get_hardware_id

Mousetrap.get_hardware_idFunction
get_hardware_id(::StylusEventController) -> Cuint

Get the native ID of the stylus-device that caused the current event.

source

get_has_base_arrow

get_has_border

get_has_close_button

get_has_focus

get_has_frame

Mousetrap.get_has_frameFunction
get_has_frame(::Button) -> Bool
get_has_frame(::Viewport) -> Bool
get_has_frame(::Entry) -> Bool
get_has_frame(::PopoverButton) -> Bool 

Get whether the widget's outline should be displayed, it will remain interactable.

source

get_has_origin

Mousetrap.get_has_originFunction
get_has_origin(::Scale) -> Bool

Get whether the area between the origin of the scales trough and the current value should be fille with a solid color.

source

get_has_wide_handle

Mousetrap.get_has_wide_handleFunction
get_has_wide_handle(::Paned) -> Bool

Get whether the barrier in between the Paned's two children is wide or thin, wide by default.

source

get_header_bar

get_hide_on_close

get_hide_on_overflow

Mousetrap.get_hide_on_overflowFunction
get_hide_on_overflow(::Widget) -> Bool

Get whether the entire widget should be hidden if its allocated area is smaller than its natural size. If false, the overflow part of the widget will be truncated.

source

get_homogeneous

Mousetrap.get_homogeneousFunction
get_homogeneous(::Box) -> Bool

Get whether all of the Box's children should be allocated the same width (or height, if orientation is ORIENTATION_VERTICAL).

source

get_horizontal_adjustment

get_horizontal_alignment

get_horizontal_scrollbar_policy

get_icon_names

get_id

Mousetrap.get_idFunction
get_id(::Application) -> ApplicationID
get_id(::Action) -> ActionID

Access the ID specified during the object's construction.

source

get_image

Mousetrap.get_imageFunction
get_image(f, ::Clipboard, [::Data_t])

Register a callback to read an image from the clipboad. Once the clipboard is ready, the callback will be invoked.

f is required to be invocable as a function with signature

(::Clipboard, ::Image, [::Data_t]) -> Cvoid

Example

clipboard = get_clipboard(window)
if contains_image(clipboard)
    get_image(clipboard) do x::Clipboard, image::Image
        # use image here
    end
end
source

get_inverted

Mousetrap.get_invertedFunction
get_inverted(::LevelBar) -> Bool

Get whether the level bar should be mirrored along the horizontal or vertical axis, depending on orientation.

source

get_is_active

Mousetrap.get_is_activeFunction
get_is_active(::CheckButton) -> Bool
get_is_active(::Switch) -> Bool
get_is_active(::ToggleButton) -> Bool

Get whether the internal state of the widget is active.

source

get_is_circular

Mousetrap.get_is_circularFunction
get_is_circular(::Button) -> Bool
get_is_circular(::ToggleButton) -> Bool
get_is_circular(::PopoverButton)  -> Bool

Get whether the button is circular (as opposed to rectangular, the default).

source

get_is_closed

Mousetrap.get_is_closedFunction
get_is_closed(::Window) -> Bool

Returns false if the window is currently active and visible to the user, true otherwise.

source

get_is_decorated

get_is_expanded

get_is_focusable

get_is_high_priority

Mousetrap.get_is_high_priorityFunction
get_is_high_priority(::PopupMessage) -> Bool

Get whether this message has a high priority. High priority messages will be shown before non-high-priority if queued with PopupMessageOverlay.

source

get_is_holding

get_is_horizontally_homogeneous

get_is_inverted

Mousetrap.get_is_invertedFunction
get_is_inverted(::ProgressBar) -> Bool

Get whether the progress bar should fill from right-to-left, instead of left-to-right

source

get_is_local

Mousetrap.get_is_localFunction
get_is_local(::Clipboard) -> Bool

Check whether the content of the cliboard was set from within the currently active Mousetrap application.

source

get_is_marked_as_busy

get_is_modal

Mousetrap.get_is_modalFunction
get_is_modal(::Window) -> Bool
get_is_modal(::FileChooser) -> Bool
get_is_modal(::ColorChooser) -> Bool
get_is_modal(::AlertDialog) -> Bool

Get whether all other windows should be paused while this window is active.

source

get_is_realized

get_is_resizable

Mousetrap.get_is_resizableFunction
get_is_resizable(::ColumnViewColumn) -> Bool

Get whether the user can choose the width of this column by click-dragging.

source

get_is_revealed

Mousetrap.get_is_revealedFunction
get_is_revealed(::Revealer) -> Bool
get_is_revealed(::ActionBar) -> Bool

Get whether the widget's child is currently visible.

source

get_is_reversed

Mousetrap.get_is_reversedFunction
get_is_reversed(::Animation) -> Bool

If false, the animation will interpolate its value from the lower to upper bound, or the other way around if true.

source

get_is_scrollable

Mousetrap.get_is_scrollableFunction
get_is_scrollable(::Notebook) -> Bool

Get whether the user can scroll between pages using the mouse scrollwheel or touchscreen.

source

get_is_selectable

Mousetrap.get_is_selectableFunction
get_is_selectable(::Label) -> Bool

Get whether the user can select part of the label, as would be needed to copy its text.

source

get_is_spinning

get_is_vertically_homogeneous

get_is_visible

Mousetrap.get_is_visibleFunction
get_is_visible(::Widget) -> Bool
get_is_visible(::ColumnViewColumn) -> Bool 

Get whether the object is currently shown on screen.


get_is_visible(::Shape) -> Bool

Get whether the shape should be omitted from rendering, where false means it will be ommitted.

source

get_item_at

get_justify_mode

Mousetrap.get_justify_modeFunction
get_justify_mode(::Label) -> JustifyMode
get_justify_mode(::TextView) -> JustifyMode

Get the currently used justify mode.

source

get_keys

Mousetrap.get_keysFunction
get_keys(::KeyFile, group::GroupID) -> Vector{KeyID}

Get all keys in this group, or an empty vector if the group does not exist.

source

get_kinetic_scrolling_enabled

Mousetrap.get_kinetic_scrolling_enabledFunction
get_kinetic_scrolling_enabled(::Viewport) -> Bool
get_kinetic_scrolling_enabled(::ScrollEventController) -> Bool

Get whether scrolling should continue once the user stopped operating the mouse wheel or touchscreen, simulating "inertia".

source

get_label_x_alignment

get_layout

Mousetrap.get_layoutFunction
get_layout(::HeaderBar) -> String

Get the layout string of the header bar. See the manual section on HeaderBar in the chapter on widgets for how layout-syntax works.

source

get_left_margin

get_lower

Mousetrap.get_lowerFunction
get_lower(::Adjustment) -> Float32
get_lower(::Scale) -> Float32
get_lower(::SpinButton) -> Float32
get_lower(::Animation) -> Float64

Get the lower bound of the underlying range.

source

get_margin_bottom

get_margin_end

get_margin_start

get_margin_top

get_max_n_columns

Mousetrap.get_max_n_columnsFunction
get_max_n_columns(grid_view::GridView) -> Signed

Get the maximum number of columns, (or rows if orientation is vertical), or -1 if unlimited.

source

get_max_value

get_max_width_chars

Mousetrap.get_max_width_charsFunction
get_max_width_chars(::Entry) -> Signed
get_max_width_chars(::Label) -> Signed

Get the maximum number of characters for which the label should allocate horizontal space, or -1 if unlimited.

source

get_maximum_size

Mousetrap.get_maximum_sizeFunction
get_maximum_size(::ClampFrame) -> Float32

Get the maximum width (or height, if vertical) the frame should constrain its child to, in pixels.

source

get_message

get_min_n_columns

get_min_value

get_minimum_size

Mousetrap.get_minimum_sizeFunction
get_minimum_size(::Widget) -> Vector2f

Get the minimum possible size the widget would have to allocate in order for it to be fully visible.

source

get_mode

Mousetrap.get_modeFunction
get_mode(::LevelBar) -> LevelBarMode

Get whether the LevelBar should display its value as a continuous bar, or segmented.

source

get_n_buttons

get_n_columns

get_n_digits

get_n_items

Mousetrap.get_n_itemsFunction
get_n_items(::Box) -> Unsigned
get_n_items(::FlowBox) -> Unsigned
get_n_items(::ListView) -> Unsigned
get_n_items(::GridView) -> Unsigned

Get the number of children.

source

get_n_pages

get_n_pixels

get_n_rows

get_n_vertices

get_name

Mousetrap.get_nameFunction
get_name(::Icon) -> String
get_name(::FileDescriptor) -> String 
get_name(::FileFilter) -> String

Get a cleartext identifier for the object.

source

get_native_handle

Mousetrap.get_native_handleFunction
get_native_handle(::TextureObject) -> Cuint
get_native_handle(::Shape) -> Cuint

Get the native OpenGL handle of the texture- or vertex buffer.

source

get_natural_size

Mousetrap.get_natural_sizeFunction
get_natural_size(::Widget) -> Vector2f

Get the size the widget would prefer to display at, if given infinite space and no expansion.

source

get_only_listens_to_button

get_opacity

get_orientation

Mousetrap.get_orientationFunction
get_orientation(::Box) -> Orientation
get_orientation(::FlowBox) -> Orientation
get_orientation(::CenterBox) -> Orientation 
get_orientation(::ClampFrame) -> Orientation
get_orientation(::LevelBar) -> Orientation 
get_orientation(::ListView) -> Orientation 
get_orientation(::GridView) -> Orientation 
get_orientation(::Grid) -> Orientation 
get_orientation(::Paned) -> Orientation 
get_orientation(::ProgressBar) -> Orientation 
get_orientation(::Scrollbar) -> Orientation 
get_orientation(::Separator) -> Orientation 
get_orientation(::SpinButton) -> Orientation
get_orientation(::SpinButton) -> Orientation

Get whether the widget is oriented horizontally or vertically.


get_orientation(::PanEventController) -> Orientation 

Get along which axis the event controller should recognize pan gestures.

source

get_parent

Mousetrap.get_parentFunction
get_parent(self::FileDescriptor) -> FileDescriptor

Get the files parent folder. If self points to root or a location that does not exist, the result may be invalid.

source

get_path

get_path_relative_to

get_pixel

Mousetrap.get_pixelFunction
get_pixel(image::Image, x::Integer, y::Integer) -> RGBA

Get the color of the pixel at given position, 1-indexed.

source

get_position

Mousetrap.get_positionFunction
get_position(::Widget) -> Vector2f

Get the current position on screen, relative to the toplevel window's origin, in pixels.


get_position(::Grid, ::Widget) -> Vector2i

Get row- and column-index of the widget, 1-indexed.


get_position(::Paned) -> Int32

Get the offset of the draggable handle, in absolute widget-space coordinates.

source

get_program_id

get_propagate_natural_height

get_propagate_natural_width

get_propagation_phase

Mousetrap.get_propagation_phaseFunction
get_propagation_phase(::EventController) -> PropagationPhase

Get the phase at which the event controller will capture events, see here for more information.

source

get_quick_change_menu_enabled

get_ratio

get_relative_position

Mousetrap.get_relative_positionFunction
get_relative_position(::Popover) -> RelativePosition
get_relative_position(::PopoverButton) -> RelativePosition

Get the position of the popover relative to the widget it is attached to.

source

get_repeat_count

Mousetrap.get_repeat_countFunction
get_repeat_count(::Animation) -> Unsigned

Get the number of cycles the animation will perform, or 0 if the animation loops endlessly.

source

get_right_margin

get_row_spacing

Mousetrap.get_row_spacingFunction
get_row_spacing(::Grid) -> Float32
get_row_spacing(::FlowBox) -> Float32

Get the margin between two rows, in pixels.

source

get_rows_homogeneous

get_scale

get_scale_delta

Mousetrap.get_scale_deltaFunction
get_scale_delta(::PinchZoomEventController) -> Float32

Get the difference between the current scale of the pinch-zoom-gesture and the scale at the point the gesture started, in absolute widget-space coordinates.

source

get_scale_factor

Mousetrap.get_scale_factorFunction
get_scale_factor(::Widget) -> Float32

Retrieves the internal scale factor that maps from window coordinates to the actual device pixels. On traditional systems this is 1, on high density outputs, it can be a higher value (typically 2).

Quoted from: https://docs.gtk.org/gtk4/method.Widget.getscalefactor.html

source

get_scale_mode

get_scope

Mousetrap.get_scopeFunction
get_scope(::ShortcutEventController) -> ShortcutScope

Get the scope in which the controller listens for shortcut events, see here for more information.

source

get_scrollbar_placement

get_selected

get_selection

get_selection_mode

get_selection_model

Mousetrap.get_selection_modelFunction
get_selection_model(::ListView) -> SelectionModel
get_selection_model(::GridView) -> SelectionModel
get_selection_model(::Stack) -> SelectionModel
get_selection_model(::ColumnView) -> SelectionModel

Get the underlying selection model of the selectable widget.

source

get_shortcuts

get_should_draw_value

get_should_interpolate_size

get_should_snap_to_ticks

Mousetrap.get_should_snap_to_ticksFunction
get_should_snap_to_ticks(::SpinButton) -> Bool

Get whether when the user enters a value using the SpinButton's text entry, that value should be clamped to the nearest tick.

source

get_should_wrap

Mousetrap.get_should_wrapFunction
get_should_wrap(::SpinButton) -> Bool

Get whether the spin button should over- or underflow when reaching the upper or lower end of its range. This needs to be set to true in order for SpinButton to emit its signal wrapped.

source

get_show_column_separators

get_show_row_separators

get_show_separators

get_show_text

Mousetrap.get_show_textFunction
get_show_text(::ProgressBar) - Bool

Get whether a percentage or custom label should be displayed above the ProgressBar. User set_text! to choose the custom label.

source

get_show_title_buttons

get_signal_activate_blocked

get_signal_activate_default_widget_blocked

get_signal_activate_focused_widget_blocked

get_signal_activate_item_blocked

get_signal_activated_blocked

get_signal_button_clicked_blocked

get_signal_click_pressed_blocked

get_signal_click_released_blocked

get_signal_click_stopped_blocked

get_signal_clicked_blocked

get_signal_close_request_blocked

get_signal_closed_blocked

get_signal_destroy_blocked

get_signal_dismissed_blocked

get_signal_drag_begin_blocked

get_signal_drag_blocked

get_signal_drag_end_blocked

get_signal_focus_gained_blocked

get_signal_focus_lost_blocked

get_signal_hide_blocked

get_signal_items_changed_blocked

get_signal_key_pressed_blocked

get_signal_key_released_blocked

get_signal_kinetic_scroll_decelerate_blocked

get_signal_map_blocked

get_signal_modifiers_changed_blocked

get_signal_motion_blocked

get_signal_motion_enter_blocked

get_signal_motion_leave_blocked

get_signal_page_added_blocked

get_signal_page_removed_blocked

get_signal_page_reordered_blocked

get_signal_page_selection_changed_blocked

get_signal_paint_blocked

get_signal_pan_blocked

get_signal_press_cancelled_blocked

get_signal_pressed_blocked

get_signal_properties_changed_blocked

get_signal_proximity_blocked

get_signal_realize_blocked

get_signal_render_blocked

get_signal_resize_blocked

get_signal_revealed_blocked

get_signal_rotation_changed_blocked

get_signal_scale_changed_blocked

get_signal_scroll_begin_blocked

get_signal_scroll_blocked

get_signal_scroll_child_blocked

get_signal_scroll_end_blocked

get_signal_selection_changed_blocked

get_signal_show_blocked

get_signal_shutdown_blocked

get_signal_stylus_down_blocked

get_signal_stylus_up_blocked

get_signal_swipe_blocked

get_signal_switched_blocked

get_signal_text_changed_blocked

get_signal_toggled_blocked

get_signal_unmap_blocked

get_signal_unrealize_blocked

get_signal_update_blocked

get_signal_value_changed_blocked

get_signal_wrapped_blocked

get_single_click_activate

Mousetrap.get_single_click_activateFunction
get_single_click_activate(::ListView) -> Bool
get_single_click_activate(::GridView) -> Bool
get_single_click_activate(::ColumnView) -> Bool

Get whether simply hovering over an item will select it.

source

get_size

Mousetrap.get_sizeFunction
get_size(::TextureObject) -> Vector2i
get_size(::Icon) -> Vector2i
get_size(::Image) -> Vector2i

Get resolution of the underlying image.


get_size(::Grid, ::Widget) -> Vector2i

Get the number of rows and columns.


get_size(::Shape) -> Vector2f

Get width and height of the axis-aligned bounding box, in OpenGL coordinates.

source

get_size_request

Mousetrap.get_size_requestFunction
get_size_request(::Widget) -> Vector2f

Get the size request, where a 0 for either width or height indicates that no size request was made.

source

get_spacing

get_start_child_resizable

get_start_child_shrinkable

Mousetrap.get_start_child_shrinkableFunction
get_start_child_shrinkable(::Paned) -> Bool

Get whether the start child can be resized such that its allocated area in the paned is less than its minimum size.

source

get_start_position

Mousetrap.get_start_positionFunction
get_start_position(controller::DragEventController) -> Vector2f

Get position at which the drag gesture was first recognized, in absolute widget-space coordinates.

source

get_state

Mousetrap.get_stateFunction
get_state(::CheckButton) -> CheckButtonState

Get current state of the check button.


get_state(::Animation) -> AnimationState

Get current state of the animation.

source

get_step_increment

Mousetrap.get_step_incrementFunction
get_step_increment(::Adjustment) -> Float32
get_step_increment(::Scale) -> Float32
get_step_increment(::SpinButton) -> Float32

Get minimum step increment of the underlying adjustment.

source

get_string

Mousetrap.get_stringFunction
get_string(f, clipboard::Clipboard, [::Data_t]) -> Cvoid

Register a callback with the signature:

(::Clipboad, ::String, [::Data_t]) -> Cvoid

When a string is read from the clipboard, the callback will be invoked and the string will be provided as the second argument for the callback.

Example

clipboard = get_clipboard(window)
if contains_string(clipboard)
    get_string(clipboard) do x::Clipboard, string::String
        # use string here
    end
end
source

get_surpress_debug

get_surpress_info

Mousetrap.get_surpress_infoFunction
get_surpress_info(::LogDomain) -> Bool

Get whether log message of level "INFO" will be ommitted from the console output.

source

get_tab_position

Mousetrap.get_tab_positionFunction
get_tab_position(::Notebook) -> RelativePosition

Get position of the tab bar relative to the center of the notebook.

source

get_tabs_reorderable

get_tabs_visible

get_target_frame_duration

Mousetrap.get_target_frame_durationFunction
get_target_frame_duration(::FrameClock) -> Time

Get the intended duration of a frame. For example, if the monitor has a refresh rate of 60hz, the target frame duration is 1/60s.

source

get_text

Mousetrap.get_textFunction
get_text(::Entry) -> String
get_text(::Label) -> String
get_text(::TextView) -> String

Get the content of the underlying text buffer.


get_text(::ProgressBar) -> String

Get text currently displayed by the ProgressBar, or "" if the percentage is displayed instead.

source

get_text_visible

get_time_since_last_frame

get_timeout

Mousetrap.get_timeoutFunction
get_timeout(::PopupMessage) -> Time 

Get the duration after which the message should hide itself, or 0 for it to never hide on its own. Microsecond precision.

source

get_timing_function

Mousetrap.get_timing_functionFunction
get_timing_function(::Animation) -> AnimationTimingFunction

Get the shape of the function used to interpolate the animation's underlying value over time.

source

get_title

Mousetrap.get_titleFunction
get_title(::Window) -> String
get_title(::FileChooser) -> String
get_title(::ColorChooser) -> String

Get the window title.


get_title(::ColumnViewColumn) -> String 

Get the title for this column, which uniquely identifies it.


get_title!(::PopupMessage) -> StringGet thePopupMessage`s text.

source

get_tool_type

Mousetrap.get_tool_typeFunction
get_tool_type(::StylusEventController) -> ToolType

Get the currently set tool type of the stylus device, or TOOL_TYPE_UNKNOWN if tool types are not supported.

source

get_top_left

Mousetrap.get_top_leftFunction
get_top_left(::Shape) -> Vector2f

Get the position of the top left corner of the axis-aligned bounding box, in OpenGL coordinates.

source

get_top_level_widget

Mousetrap.get_top_level_widgetFunction
get_top_level_widget(::Widget) -> Widget

Function that maps a non-native compount widget (subtyping Widget) to its top-level widget component.

See the manual section on compound widgets in the chapter on widgets for more information.

Example

```julia struct CompoundWidget <: Widget box::Box CompoundWidget() = new(hbox(Label("this is a compound widget"))) end

Mousetrap.gettoplevel_widget(x::CompoundWidget) = x.box

after this definition, CompoundWidget can be used like any native Mousetrap widget

source

get_top_margin

get_touch_only

Mousetrap.get_touch_onlyFunction
get_touch_only(::SingleClickGesture) -> Bool

Get whether the event controller should exclusively react to events from touch-devices.

source

get_transition_duration

get_transition_type

Mousetrap.get_transition_typeFunction
get_transition_type(::Stack) -> StackTransitionType
get_transition_type(::Revealer) -> RevealerTransitionType

Get type of animation used for the transition animation.

source

get_uniform_float

Mousetrap.get_uniform_floatFunction
get_uniform_float(::RenderTask, name::String) -> Cfloat

Get a registered uniform float, or 0.0 if no such uniform was registered.

source

get_uniform_hsva

Mousetrap.get_uniform_hsvaFunction
get_uniform_hsva(task::RenderTask, name::String) -> HSVA

Get uniform vec4, or HSVA(0, 0, 0, 0) if no such uniform exists.

source

get_uniform_int

Mousetrap.get_uniform_intFunction
get_uniform_int(::RenderTask, name::String) -> Cint

Get a registered uniform int, or 0 if no such uniform was registered.

source

get_uniform_location

Mousetrap.get_uniform_locationFunction
get_uniform_location(::Shader, name::String) -> Cuint

Get the OpenGL shader program uniform location for the given uniform name, or -1 if no such uniform exists. Note that uniform names may be optimized away by the GLSL compiler if they go unused.

source

get_uniform_rgba

Mousetrap.get_uniform_rgbaFunction
get_uniform_rgba(task::RenderTask, name::String) -> RGBA

Get uniform vec4, or RGBA(0, 0, 0, 0) if no such uniform exists.

source

get_uniform_transform

Mousetrap.get_uniform_transformFunction
get_uniform_transform(task::RenderTask, name::String) -> GLTransform

Get uniform mat4x4, or the identity transform if no such uniform exists.

source

get_uniform_uint

get_uniform_vec2

Mousetrap.get_uniform_vec2Function
get_uniform_vec2(task::RenderTask, name::String) -> Vector2f

Get uniform vec2, or Vector2f(0, 0) if no such uniform exists.

source

get_uniform_vec3

get_uniform_vec4

Mousetrap.get_uniform_vec4Function
get_uniform_vec4(task::RenderTask, name::String) 

Get uniform vec4, or Vector4f(0, 0, 0, 0) if no such uniform exists.

source

get_upper

Mousetrap.get_upperFunction
get_upper(::Adjustment) -> Float32
get_upper(::Scale) -> Float32
get_upper(::SpinButton) -> Float32
get_upper(::Animation) -> Float64

Get upper bound of the underlying range.

source

get_uri

Mousetrap.get_uriFunction
get_uri(::FileDescriptor) -> String

Transform the descriptor's path to URI format.

source

get_use_markup

get_value

Mousetrap.get_valueFunction
get_value(::Adjustment) -> Float32
get_value(::SpinButton) -> Float32
get_value(::Scale) -> Float32
get_value(::LevelBar) -> Float32
get_value(::Animation) -> Float64

Get current value of the underlying adjustment.


get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{<:AbstractFloat})
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Vector{T}}) where T <: AbstractFloat 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{<:Signed}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Vector{T}}) where T <: Signed 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{<:Unsigned}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Vector{T}}) where T <: Unsigned 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Bool}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Vector{Bool}}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{String}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Vector{String}}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{RGBA}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{HSVA}) 
get_value(file::KeyFile, ::GroupID, ::KeyID, ::Type{Image}) 

Deserialize a value from the keyfile, then return it as a the specfied type. Returns a default value if the key-value pair or group does not exist, or it cannot be converted to the given type.

source

get_velocity

Mousetrap.get_velocityFunction
get_velocity(SwipeEventController) -> Vector2f

Get the swipes current velocity, in absolute widget-space coordinates.

source

get_vertex_color

Mousetrap.get_vertex_colorFunction
get_vertex_color(::Shape, index::Integer) -> RGBA

Get color of the vertex at given index, or RGBA(0, 0, 0, 0) if index is out of bounds.

source

get_vertex_color_location

get_vertex_position

get_vertex_position_location

get_vertex_shader_id

get_vertex_texture_coordinate

get_vertex_texture_coordinate_location

get_vertical_adjustment

get_vertical_alignment

get_vertical_scrollbar_policy

get_visible_child

get_was_modified

get_wrap_mode

Mousetrap.get_wrap_modeFunction
get_wrap_mode(::Label) -> LabelWrapMode

Get the mode use to determine at which point in a line a linebreak will be inserted.


get_wrap_mode(::TextureObject) -> TextureWrapMode

Get the OpenGL texture wrap mode.

source

get_x_alignment

get_y_alignment

goto_page!

Mousetrap.goto_page!Function
goto_page!(::Notebook, position::Integer) 

Jump to page at given index, or the last page if position is out of bounds.

source

grab_focus!

has_action

Mousetrap.has_actionFunction
has_action(::Application, id::String) -> Bool

Check whether an action with the given ID is registered.

source

has_axis

Mousetrap.has_axisFunction
has_axis(::StylusEventController, ::DeviceAxis) -> Bool

Check whether a stylus-device supports the given axis.

source

has_column_with_title

has_group

Mousetrap.has_groupFunction
has_group(::KeyFile, group::GroupID) -> Bool

Check if the KeyFile has a group with given id.

source

has_icon

Mousetrap.has_iconFunction
has_icon(::IconTheme, icon::Icon) -> Bool
has_icon(::IconTheme, id::String) -> Bool

Check whether icon theme has an icon.

source

has_key

Mousetrap.has_keyFunction
has_key(::KeyFile, group::GroupID, key::KeyID) -> Bool

Check whether the key file has a group with the given ID, and whether that group has a key with given ID.

source

hbox

Mousetrap.hboxFunction
hbox(::Widget...) -> Box

Convenience function that wraps list of a widget in a horizonally oriented box.

source

hide!

Mousetrap.hide!Function
hide!(::Widget) 

Hide the widget, this means its allocated size will become 0 and all of its children will be hidden.

source

hold!

hsva_to_rgba

html_code_to_rgba

insert_after!

Mousetrap.insert_after!Function
insert_after!(::Box, to_append::Widget, after::Widget) 

Insert to_append such that it comes right after after.

source

insert_at!

Mousetrap.insert_at!Function
insert_at!(::FlowBox, ::Widget, index::Integer) -> Cvoid
insert_at!(::ListView, ::Widget, index::Integer, [::ListViewIterator]) -> ListViewIterator
insert_at!(::GridView, inde::Integer, ::Widget) -> Cvoid
insert_at!(::Grid, ::Widget, row_i::Signed, column_i::Signed, [n_horizontal_cells:Unsigned = 1, n_vertical_cells::Unsigned = 1]) -> Cvoid

Insert a widget at the given position.


insert_at!(::DropDown, index::Integer, label_for_both::String) -> DropDownItemID
insert_at!(::DropDown, index::Integer, list_widget::Widget, label_widget::Widget) -> DropDownItemID
insert_at!(f, ::DropDown, index::Integer, list_widget::Widget, label_widget::Widget, [::Data_t]) -> DropDownItemID
insert_at!(f, ::DropDown, index::Integer, label_for_both::String, [::Data_t]) -> DropDownItemID

Add an item to the drop down at given index. When it is selected label_widget will appear as the child of the drop down, while list_widget will be used as the widget displayed when the drop down menu is open.

f is called when the corresponding item is select. f is required to be invocable as a function with the signature

(::DropDown, [::Data_t]) -> Cvoid

Returns a unique ID identifying the inserted item.

See the manual section on DropDown in the chapter on widgets for more information.


insert_at!(::Notebook, index::Integer, child_widget::Widget, label_widget::Widget)

Insert a page at the given position, where child_widget is the widget used as the page, and label_widget is the widget displayed in the tab bar.

source

insert_column_at!

Mousetrap.insert_column_at!Function
insert_column_at!(grid::Grid, column_i::Signed) 

Insert an empty column after the given index (may be negative).


insert_column:at!(column_view::ColumnView, index::Integer, title::String) 

Insert a column at the given index. Each row of the column will be empty.

source

insert_next_to!

Mousetrap.insert_next_to!Function
insert_next_to!(::Grid, to_insert::Widget, already_in_grid::Widget, position::RelativePosition, [n_horizontal_cells:Unsigned = 1, n_vertical_cells::Unsigned = 1]) -> Cvoid

Insert widget into a grid such that it is now next to already_in_grid, where position describes the relative position of already_in_grid to to_insert.

source

insert_row_at!

Mousetrap.insert_row_at!Function
insert_row_at!(grid::Grid, row_i::Signed) 

Insert an empty row after the given index (may be negative).


insert_row_at!(::ColumnView, index::Integer, widgets::Widget...)

Insert a number of widgets as a row, inserting them into the corresponding column. If the number of widgets is lower than the number of columns, the left-over columns will contain an empty cell in that row.

source

is_cancelled

is_executable

is_file

Mousetrap.is_fileFunction
is_file(::FileDescriptor) -> Bool

Check whether the location on disk contains points to a valid file (not folder).

source

is_folder

Mousetrap.is_folderFunction
is_folder(::FileDescriptor) -> Bool

Check whether the location on disk contains points to a valid folder (not file).

source
Mousetrap.is_symlinkFunction
is_symlink(::FileDescriptor) -> Bool

Get whether the location on disk is a valid symbolic link.

source

is_valid_html_code

log_critical

Mousetrap.log_criticalFunction
log_critical(::LogDomain, message::Sting)
@log_critical(::LogDomain, message::Sting)

Display a log message with level CRITICAL. If set_log_file! was called before, the message will also be appended to that file.

source

log_debug

Mousetrap.log_debugFunction
log_debug(::LogDomain, message::Sting)
@log_debug(::LogDomain, message::Sting)

Display a log message with level DEBUG. Messages of this level will only be displayed once set_surpress_debug! is set to false for this log domain.

If set_log_file! was called before, the message will also be appended to that file.

source

log_fatal

Mousetrap.log_fatalFunction
log_fatal(::LogDomain, message::Sting)
@log_fatal(::LogDomain, message::Sting)

Dispay a log message with level FATAL. Immediately after, runtime ends. If set_log_file! was called before, the message will also be appended to that file.

source

log_info

Mousetrap.log_infoFunction
log_info(::LogDomain, message::Sting)
@log_info(::LogDomain, message::Sting)

Display a log message with level INFO. Messages of this level can be surpressed by setting set_surpress_info! for this log domain to true.

If set_log_file! was called before, the message will also be appended to that file.

source

log_warning

Mousetrap.log_warningFunction
log_warning(::LogDomain, message::Sting)
@log_warning(::LogDomain, message::Sting)

Display a log message with level WARNING. If set_log_file! was called before, the message will also be appended to that file.

source

main

Mousetrap.mainFunction
main(f; application_id::ApplicationID) 

Run f, which is required to be invocable as a function with signature

(::Application, [::Data_t]) -> Cvoid

This function automatically creates an application with given ID and starts the main loop. If an error occurrs during f, the application safely exits.

Example

using Mousetrap
main() do app::Application
    window = Window(app)
    present!(window)
end
source

make_current

Mousetrap.make_currentFunction
make_current(::RenderArea) 
make_current(::GLArea)

Bind the associated frame buffer as the one currently being rendered to. This is usually not necessary.

source

mark_as_busy!

Mousetrap.mark_as_busy!Function
mark_as_busy!(::Application) 

Mark the application as busy, this will tell the OS that the application is currently processing something. The caller of this function is reponsible for calling unmark_as_busy! to undo this action.

source

microseconds

milliseconds

minutes

mouse_button_01_pressed

mouse_button_02_pressed

move!

Mousetrap.move!Function
move!(from::FileDescriptor, to::FileDescriptor, allow_overwrite::Bool ; [make_backup::Bool = false, follow_symlink::Bool = true]) -> Bool 

Move a file to a different location. Returns true if the operation was successful.

source

move_page_to!

Mousetrap.move_page_to!Function
move_page_to!(::Notebook, current_index::Integer, new_index::Integer)

Move notebook page at position current_index to position new_index, 1-based. This will emit signal page_reordered.

source

move_to_trash!

Mousetrap.move_to_trash!Function
move_to_trash!(file::FileDescriptor) ::Bool

Safely move the file to the operating system garbage bin. This operation can be undone by the user. Returns true if the operation was successful.

source

nanoseconds

next_page!

on_accept!

Mousetrap.on_accept!Function
on_accept!(f, chooser::FileChooser, [::Data_t]) 

Register a callback to be called when the user clicks the "accept" button.

f is required to be invocable as a function with signature

(::FileChooser, ::Vector{FileDescriptor}, [::Data_t]) -> Cvoid

Example

file_chooser = FileChooser(FILE_CHOOSER_ACTION_OPEN_FILE)
on_accept!(file_chooser) do x::FileChooser, files::Vector{FileDescriptor}
   # use `files` here
end
````
---

onaccept!(f, chooser::ColorChooser, [::Datat])

Register a callback to be called when the users makes a color selection. `f` is required to be invocable as a function with signature:

(::FileChooser, ::RGBA, [::Data_t]) -> Cvoid


## Example

julia colorchooser = ColorChooser() onaccept!(color_chooser) do self::ColorChooser, color::RGBA

use color here

end ```

source

on_cancel!

Mousetrap.on_cancel!Function
on_cancel!(f, chooser::FileChooser, [::Data_t]) 

Register a callback to be called when the user clicks the "cancel" button f the file chooser. f is required to be invocable as a function with signature

(::FileChooser, [::Data_t]) -> Cvoid

Example

file_chooser = FileChooser(FILE_CHOOSER_ACTION_OPEN_FILE)
on_cancel!(file_chooser) do x::FileChooser
    println("file selection cancelled.")
end

on_cancel!(f, chooser::ColorChooser, [::Data_t]) 

Register a callback to be called the users cancels color selection or otherwise closes the dialog. f is required to be invocable as a function with signature:

(::FileChooser, [::Data_t]) -> Cvoid

Example

julia color_chooser = ColorChooser() on_cancel!(color_chooser) do self::ColorChooser println("color selection cancelled") end`

source

on_done!

Mousetrap.on_done!Function
on_done!(f, ::Animation, [::Data_t])

Register a callback called when the animations state changes from ANIMATION_STATE_PLAYING to ANIMATION_STATE_DONE.

f is required to be invocable as a function with signature

(::Animation, [::Data_t]) -> Cvoid

Example

animation = Animation(widget, seconds(1))
on_done!(animation) do self::Animation
    println("done")
end
play!(animation)
source

on_file_changed!

Mousetrap.on_file_changed!Function
on_file_changed!(f, monitor::FileMonitor, [::Data_t]) 

Register a callback to be called when the monitored file is modified. f is required to be invocable as a function with signature

(::FileMonitor, ::FileMonitorEvent, self::FileDescriptor, other::FileDescriptor) -> Cvoid

Where other may not point to a valid file, depending on the event type.

Example

file = FileDescriptor("path/to/file.jl")
@assert(exists(file))
monitor = create_monitor(file)
on_file_changed!(monitor) do x::FileMonitor, event_type::FileMonitorEvent, self::FileDescriptor, other::FileDescriptor
    if event_type == FILE_MONITOR_EVENT_CHANGED
        println("File at " * get_path(self) * " was modified.")
    end
end
source

on_selection!

Mousetrap.on_selection!Function
on_selection!(f, ::AlertDialog, [::Data_t])

Register a callback to be called when the user clicks one of the dialogs buttons or dismisses the dialog. f is required to be invocable as a function with signature

(::AlertDialog, button_index::Signed, [::Data_t]) -> Cvoid

Where button_index is the index of the current button (1-based), or 0 if the dialog was dismissed.

Example

alert_dialog = AlertDialog(["Yes", "No"], "Is this is a dialog?")
on_selection!(alert_dialog) do self::AlertDialog, button_index::Signed
    if button_index == 0
        println("User dismissed the dialog")
    else
        println("User chose $(get_button_label(self, button_index))")
    end
end
present!(alert_dialog)
source

on_tick!

Mousetrap.on_tick!Function
on_tick!(f, ::Animation, [::Data_t])

Register a callback called every frame while the animmation is active. f is required to be invocable as a function with signature

(::Animation, value::AbstractFloat, [::Data_t]) -> Cvoid

Where value is the currently interpolated value.

Example

animation = Animation(widget, seconds(1))
on_tick!(animation) do self::Animation, value::AbstractFloat
    # use `value` here
end
play!(animation)
source

open_file

Mousetrap.open_fileFunction
open_file(::FileDescriptor) -> Cvoid

Asynchronously launch the default application to open the file or folder. May present the users with a list of applications they can choose from.

source

open_url

Mousetrap.open_urlFunction
open_url(uri::String) -> Cvoid

Asynchronously launch the default application to open the uri. This will usually be the users web browser

source

pause!

Mousetrap.pause!Function
pause!(::Animation)

If the animation is playing, pause it, otherwise does nothing.

source

play!

Mousetrap.play!Function
play!(::Animation)

If the animation is currently paused, resume playing, otherwise restart the animation from the beginning.

source

popdown!

popup!

present!

Mousetrap.present!Function
present!(::Window) 
present!(::Popover) 
present!(::FileChooser) 
present!(::ColorChooser)
present!(::AlertDialog)

Show the window to the user.

source

previous_page!

pulse

Mousetrap.pulseFunction
pulse(::ProgressBar) 

Trigger an animation that signifies to the user that progress has been made. This does not actually increase the displayed ratio of the progress bar.

source

push_back!

Mousetrap.push_back!Function
push_back!(::Box, ::Widget) -> Cvoid
push_back!(::FlowBox, ::Widget) -> Cvoid
push_back!(::ListView, ::Widget, [::ListViewIterator]) -> ListViewIterator 
push_back!(::GridView, ::Widget) -> Cvoid
push_back!(::HeaderBar, ::Widget) -> Cvoid
push_back!(::ActionBar, ::Widget) -> Cvoid

Add a widget to the end of the container.


push_back!(::DropDown, label_for_both::String) -> DropDownItemID
push_back!(::DropDown, list_widget::Widget, label_widget::Widget) -> DropDownItemID
push_back!(f, drop_down::DropDown, list_widget::Widget, label_widget::Widget, [::Data_t]) -> DropDownItemID
push_back!(f, drop_down::DropDown, label_for_both::String, [::Data_t]) -> DropDownItemID

Add an item to the end of the drop down. When it is selected label_widget will appear as the child of the drop down, while list_widget will be used as the widget displayed when the drop down menu is open.

f is called when the corresponding item is select. f is required to be invocable as a function with the signature

(::DropDown, [::Data_t]) -> Cvoid

Returns a unique ID identifying the inserted item.

See the manual section on DropDown in the chapter on widgets for more information.


push_back!(::Notebook, inde::Integer, child_widget::Widget, label_widget::Widget) 

Insert a page at the end of the notebook, where child_widget is the widget used as the page, and label_widget is the widget displayed in the tab bar.

source

push_back_column!

push_back_row!

Mousetrap.push_back_row!Function
push_back_row!(column_view::ColumnView, widgets::Widget...) -> Cvoid

Add a number of widgets to the end of the rows, inserting them into the corresponding column. If the number of widgets is lower than the number of columns, the left-over columns will contain an empty cell in that row.

source

push_front!

Mousetrap.push_front!Function
push_front!(::Box, ::Widget) -> Cvoid
push_front!(::FlowBox, ::Widget) -> Cvoid
push_front!(::ListView, ::Widget, [::ListViewIterator]) -> ListViewIterator 
push_front!(::GridView, ::Widget) -> Cvoid
push_front!(::HeaderBar, ::Widget) -> Cvoid
push_front!(::ActionBar, ::Widget) -> Cvoid

Add a widget to the start of the container.


push_front!(::DropDown, label_for_both::String) -> DropDownItemID
push_front!(::DropDown, list_widget::Widget, label_widget::Widget) -> DropDownItemID
push_front!(f, drop_down::DropDown, list_widget::Widget, label_widget::Widget, [::Data_t]) -> DropDownItemID
push_front!(f, drop_down::DropDown, label_for_both::String, [::Data_t]) -> DropDownItemID

Add an item to the start of the drop down. When it is selected label_widget will appear as the child of the drop down, while list_widget will be used as the widget displayed when the drop down menu is open.

f is called when the corresponding item is select. f is required to be invocable as a function with the signature

(::DropDown, [::Data_t]) -> Cvoid

Returns a unique ID identifying the inserted item.

See the manual section on DropDown in the chapter on widgets for more information.


push_front!(::Notebook, inde::Integer, child_widget::Widget, label_widget::Widget) 

Insert a page at the start of the notebook, where child_widget is the widget used as the page, and label_widget is the widget displayed in the tab bar.

source

push_front_column!

Mousetrap.push_front_column!Function
push_front_column!(column_view::ColumnView, title::String) -> ColumnViewColumn

Add a column to the start of the column view.

source

push_front_row!

Mousetrap.push_front_row!Function
push_front_row!(column_view::ColumnView, widgets::Widget...) -> Cvoid

Add a number of widgets to the start of the rows, inserting them into the corresponding column. If the number of widgets is lower than the number of columns, the leftover columns will contain an empty cell in that row.

source

query_info

Mousetrap.query_infoFunction
query_info(::FileDescriptor, attribute_id::String) -> String

Access metadata info about a file. A list of attribute IDs can be found here. Note that there is no guarantee that a file will contain a value for any of these attributes.

source

queue_render

Mousetrap.queue_renderFunction
queue_render(::RenderArea) 
queue_render(::GLArea)

Request for the RendeArea to performa a render cycle and flush the current framebuffer to the screen. There is no guarantee that this will happen immediately.

source

quit!

radians

Mousetrap.read_symlinkFunction
read_symlink(self::FileDescriptor) -> FileDescriptor

If the file location is a valid symlink, follow that symlink and return the resulting file.

source

redo!

Mousetrap.redo!Function
redo!(::TextView) 

Invoke the "redo!" keybinding signal. If there is no action on the undo stack, this function does nothing.

source

release!

Mousetrap.release!Function
release!(::Application) 

Release an application that is currently being prevented from exiting because hold! was called before.

source

remove!

Mousetrap.remove!Function
remove!(::Box, ::Widget) -> Cvoid
remove!(::FlowBox, ::WIdget) -> Cvoid
remove!(::ActionBar, ::Widget) -> Cvoid
remove!(::ListView, index::Integer, [::ListViewIterator]) -> Cvoid 
remove!(::GridView, ::Widget) -> Cvoid
remove!(::Grid, ::Widget) -> Cvoid
remove!(::HeaderBar, ::Widget) -> Cvoid
remove!(::DropDown, item_id::DropDownItemID) -> Cvoid
remove!(::Notebook, position::Integer) -> Cvoid

Remove an item from the container.

source

remove_action!

Mousetrap.remove_action!Function
remove_action!(::Application, id::String) 

Unregister an action from the application. Any connected widgets such as Button or MenuModel will be disabled.


remove_action!(::ShortcutEventController, ::Action) 

Remove an action, such that the controller will not longer trigger it if any of its shortcuts are recognized.

source

remove_center_child!

remove_child!

Mousetrap.remove_child!Function
remove_child!(::Fixed, child::Widget) 
remove_child!(::Window) 
remove_child!(::AspectFrame) 
remove_child!(::Button) 
remove_child!(::CheckButton) 
remove_child!(::ToggleButton) 
remove_child!(::Expander) 
remove_child!(::Frame) 
remove_child!(::Overlay) 
remove_child!(::PopupMessageOverlay)
remove_child!(::Popover) 
remove_child!(::PopoverButton) 
remove_child!(::Stack, id::String) 
remove_child!(::Revealer) 
remove_child!(::Viewport) 
remove_child!(::TransformBin)

Remove the widget's singular child, such that it is now empty.

source

remove_column!

Mousetrap.remove_column!Function
remove_column!(::ColumnView, column::ColumnViewColumn) 

Remove a column from the column view, this also frees all of its rows.

source

remove_column_at!

Mousetrap.remove_column_at!Function
remove_column_at!(::Grid, column_i::Signed)

Remove column at given index (1-based, may be negative). Any following columns will be shifted to the left.

source

remove_controller!

remove_css_class!

remove_end_child!

remove_extra_widget!

remove_label_widget!

Mousetrap.remove_label_widget!Function
remove_label_widget!(::Expander) 
remove_label_widget!(::Frame) 

Remove the label widget of the widget, such that it now has no label widget.

source

remove_marker!

remove_overlay!

remove_popover!

remove_primary_icon!

remove_row_at!

remove_secondary_icon!

remove_start_child!

Mousetrap.remove_start_child!Function
remove_start_child!(::Paned) 
remove_start_child!(::CenterBox) 

Remove the start child such that the widget is now empty at that position

source

remove_texture!

Mousetrap.remove_texture!Function
remove_texture!(::Shape) 

Make it such that shape no long has a texture, meaning it will be rendered as a solid color.

source

remove_tick_callback!

Mousetrap.remove_tick_callback!Function
remove_tick_callback!(::Widget) 

Remove a registered tick callback. Usually, this should be done by returning TICK_CALLBACK_RESULT_DISCONTINUE from within the tick callback function.

source

remove_title_widget!

Mousetrap.remove_title_widget!Function
remove_title_widget!(::HeaderBar)

Remove widget that is currently used as the title element, and instead use the default window title. To completely hide the title, use set_title!(window, "") on the associated window instance.

source

remove_tooltip_widget!

render

Mousetrap.renderFunction
render(::RenderTask) 
render(shape::Shape, shader::Shader, transform::GLTransform) 

Draw a shape to the currently bound framebuffer, forwarding the transform to the vertex shader and applying the fragment shader to all fragments of the shape.

Note that calling this function is usually not necessary, instead, regsiter a RenderTask with a RenderArea using add_render_task!, after which the task will be automatically rendered every frame, unless a custom signal handler was connected to RenderAreas signal render.

source

render_render_tasks

Mousetrap.render_render_tasksFunction
render_render_tasks(::RenderArea) 

Render all registered render tasks. This is only necessary when a custom signal handler is connected to the areas signal render.

source

reset!

Mousetrap.reset!Function
reset!(::Animation)

Return the animations state to idle.


reset!(::GLTransform) 
reset!(::TransformBin)

Override the transform such that it is now the identity transform.

source

reset_text_to_value_function!

reset_value_to_text_function!

restart!

Mousetrap.restart!Function
restart!(clock::Clock) -> Time

Restart the clock and return the elapsed time since the last restart.

source

rgba_to_hsva

rgba_to_html_code

Mousetrap.rgba_to_html_codeFunction
rgba_to_html_code(rgba::RGBA) -> String

Convert the color to an html-style hexadecimal string of the form #RRGGBB. The alpha component is ignored.

source

rotate!

Mousetrap.rotate!Function
rotate!(::TransformBin, angle::Angle)

Rotate child widget around its center.


rotate!(::GLTransform, angle::Angle, [origin::Vector2f]) 
rotate!(::Shape, angle::Angle, [origin::Vector2f]) 

Rotate around a point, in OpenGL coordinates.

source

run!

Mousetrap.run!Function
run!(app::Application) -> Cint

Start the main loop, initializing the internal state and triggering Applications signal activate. Note that no part of Mousetrap should be used or initialized before this function is called.

Usually, users are encouraged to use main instead, which does this automatically.

Example

app = Application("example.app")
connect_signal_activate!(app) app::app
    # all initialization should happen here
end
run(app) # start the main loop
source

save_to_file

Mousetrap.save_to_fileFunction
save_to_file(::Image, path::String) -> Bool

Save the image to a file, the file format is automatically determined based on the extension of the given path.

Returns true if the operation was successfull.


save_to_file(::KeyFile, path::String) -> Bool

Serialize the key file to a string and save that string to a file. Usually, the extension for this file should be .ini.

Returns true if the operation was successfull

source

scale!

Mousetrap.scale!Function
scale!(::TransformBin, x_scale::Number, y_scale::Number)
scale!(::GLTransform, x_scale::AbstractFloat, y_scale::AbstractFloat) 

Combine the transform with a scale transform. To scale around a point, first translate! the transform to that point, then apply scale!, then translate! the transform back to origin.

Uses relative scale, where 2 is twice as big, 0.5 is half as big, 1 is no change compared to the original size.

source

seconds

select!

Mousetrap.select!Function
select!(::SelectionModel, i::Integer, [unselect_others::Bool = true]) 

Select item at given position, this will emit signal selection_changed.

source

select_all!

Mousetrap.select_all!Function
select_all!(::SelectionModel) 

Select all items, triggering emission of signal selection_changed. This is only possible if the selection mode is SELECTION_MODE_MULTIPLE.

source

self_is_focused

Mousetrap.self_is_focusedFunction
self_is_focused(::FocusEventController) -> Bool

Check if the widget the controller was added to currently holds focus.

source

self_or_child_is_focused

Mousetrap.self_or_child_is_focusedFunction
self_or_child_is_focused(::FocusEventController) -> Bool

Check if the widget the controller was added to, or any of the widgets children currently hold focus.

source

serialize

Mousetrap.serializeFunction
serialize(::RGBA) -> String
serialize(::HSVA) -> String

Convert the object to its CSS representation.

source

set_acceleration_rate!

Mousetrap.set_acceleration_rate!Function
set_acceleration_rate!(::SpinButton, factor::AbstractFloat) 

Set the rate at which the SpinButton's value accelerates when a button is held down, where 0.0 is default rate, 0.1 is 10%, 1.0 is 100%, etc. May not be negative.

source

set_accept_label!

set_action!

Mousetrap.set_action!Function
set_action!(::Button, ::Action) 

Connect an action to the button. When the button is clicked, the action is activated. When the action is disabled, the button is also disabled.

Note that a button can have both an action and a signal handler connected. If this is the case and the button is clicked, both are triggered.

source

set_alignment!

Mousetrap.set_alignment!Function
set_alignment!(::Widget, both::Alignment) 

Set both the horizontal and vertical alignment of a widget at the same time.

source

set_allow_only_numeric!

set_always_show_arrow!

Mousetrap.set_always_show_arrow!Function
set_always_show_arrow!(::DropDown, ::Bool) 
set_always_show_arrow!(::PopoverButton, ::Bool) 

Set wether an arrow should be drawn next to the label.

source

set_application!

Mousetrap.set_application!Function
set_application!(window::Window, app::Application) 

Register the window with the application. This is usually done automatically.

source

set_auto_render!

Mousetrap.set_auto_render!Function
set_auto_render(::GLArea, ::Bool)

Set whether the render signal should be emitted anytime the widget is drawn to the screen, true by default.

source

set_autohide!

Mousetrap.set_autohide!Function
set_autohide!(::Popover, ::Bool) 

Set whether the popover should hide itself when the attached widget looses focus.

source

set_bottom_margin!

set_button_action!

Mousetrap.set_button_action!Function
set_button_action!(::PopupMessage, ::Action)

Connect an action to the singular button of the message. Note that the messages button label has to be set to anything other than "" for the button to be visible.

source

set_button_label!

Mousetrap.set_button_label!Function
set_button_label!(::AlertDialog, id::Integer, label::String)

Replace the label of the button with given ID, obtained when calling add_button!.


set_button_label!(::PopupMessage, label::String)

If label is not empty, add a singular button to the message with the given label. When that button is clicked, the PopupMessage will emit signal button_clicked.

source

set_can_respond_to_input!

Mousetrap.set_can_respond_to_input!Function
set_can_respond_to_input!(::Widget, ::Bool) 

Set whether the widget can receive input events. If set to false, the widget may appear "greyed out", signaling to the user that it is inactive.

source

set_center_child!

Mousetrap.set_center_child!Function
set_center_child!(::CenterBox, ::Widget) 
set_center_child!(::ActionBar, ::Widget) 

Set the middle child of the center box.

source

set_centroid!

Mousetrap.set_centroid!Function
set_centroid!(::Shape, centroid::Vector2f) 

Move the shape such that its centroid is now at given position, in OpenGL coordinates.

source

set_child!

Mousetrap.set_child!Function
set_child!(::Window, child::Widget) 
set_child!(::AspectFrame, child::Widget) 
set_child!(::Button, child::Widget) 
set_child!(::CheckButton, child::Widget) 
set_child!(::ToggleButton, child::Widget) 
set_child!(::Viewport, child::Widget) 
set_child!(::Expander, child::Widget) 
set_child!(::Frame, child::Widget) 
set_child!(::Overlay, child::Widget) 
set_child!(::PopupMessageOverlay, child::Widget)
set_child!(::Popover, child::Widget) 
set_child!(::PopoverButton, child::Widget) 
set_child!(::Revealer, child::Widget) 
set_child!(::TransformBin, child::Widget)

Set the widget's singular child.

source

set_child_position!

Mousetrap.set_child_position!Function
set_child_position!(::Fixed, child::Widget, position::Vector2f) 

Set fixed position of the child, in absolute widget-space coordinates.

source

set_child_x_alignment!

set_child_y_alignment!

set_color!

Mousetrap.set_color!Function
set_color!(::Shape, ::RGBA)
set_color!(::Shape, ::HSVA)

Set the color of all vertices of the shape.

source

set_column_spacing!

Mousetrap.set_column_spacing!Function
set_column_spacing!(::FlowBox, spacing::AbstractFloat)
set_column_spacing!(::Grid, spacing::AbstractFloat) 

Set spacing between two columns of the grid, in pixels.

source

set_columns_homogeneous!

set_comment_above!

Mousetrap.set_comment_above!Function
set_comment_above!(::KeyFile, ::GroupID, comment::String) 
set_comment_above!(::KeyFile, ::GroupID, ::KeyID, comment::String) 

Set the singular comment above a group or key-value pair in the file.

source

set_current_blend_mode

Mousetrap.set_current_blend_modeFunction
set_current_blend_mode(::BlendMode; allow_alpha_blending::Bool = true) 

Enable GPU-side blending and set the current OpenGL blend mode. If allow_alpha_blending is set to false, only the rgb components of a fragment's color will participate in blending.

source

set_current_theme!

Mousetrap.set_current_theme!Function
set_current_theme!(::Application, ::Theme)

Swap the global theme used to determine all widgets looks and colors. This function is only available, after the backend has been initialized.

source

set_cursor!

Mousetrap.set_cursor!Function
set_cursor!(::Widget, cursor::CursorType) 

Set which cursor shape should be used when the cursor is over the allocated area of the widget.

source

set_cursor_from_image!

Mousetrap.set_cursor_from_image!Function
set_cursor_from_image!(::Widget, image::Image, [offset::Vector2i = Vector2i(0, 0)]) 

Set which image should be displayed when the cursor is over the allocated area of the widget. offset determines the vertical and horizontal offset of the center of the image, relative to the cursor position, in pixels.

source

set_cursor_visible!

set_default_button!

Mousetrap.set_default_button!Function
set_default_button!(::AlertDialog, id::Integer)

Mark a button as the default response using the id obtained when calling add_button!. This will change the buttons look and make it such that that button becomes the default widget of the dialogs window.

source

set_default_widget!

Mousetrap.set_default_widget!Function
set_default_widget!(window::Window, ::Widget) 

Designate a widget as the default widget. When the window is activated, for example by the user pressing the enter key, the default widget is activated.

source

set_delay_factor!

Mousetrap.set_delay_factor!Function
set_delay_factor!(::LongPressEventController, factor::AbstractFloat) 

Set a factor that multiplies the default delay after which a longpress gesture is recognized.

source

set_destroy_with_parent!

set_detailed_description!

set_duration!

set_editable!

set_ellipsize_mode!

set_enable_rubberband_selection!

Mousetrap.set_enable_rubberband_selection!Function
set_enable_rubberband_selection!(::ListView, ::Bool) 
set_enable_rubberband_selection!(::GridView, ::Bool) 
set_enable_rubberband_selection!(::ColumnView, ::Bool) 

Set whether the user can select multiple children by holding down the mouse button and click-dragging. The selectable widgets selection mode has to be SELECTION_MODE_MULTIPLE in order for this to be possible.

source

set_enabled!

Mousetrap.set_enabled!Function
set_enabled!(::Action, ::Bool) 

Set whether the action is enabled. If set to false, all connected buttons and menu items will be disabled as well.

source

set_end_child!

Mousetrap.set_end_child!Function
set_end_child!(::CenterBox, child::Widget) 
set_end_child!(::Paned, child::Widget) 

Set the latter child of the widget.

source

set_end_child_resizable!

set_end_child_shrinkable!

Mousetrap.set_end_child_shrinkable!Function
set_end_child_shrinkable!(::Paned, ::Bool)

Set whether the user can resize the end child such that its allocated area inside the paned is smaller than the natural size of the child.

source

set_expand!

Mousetrap.set_expand!Function
set_expand!(::Widget, ::Bool) 

Set whether the widget should expand along both the horizontal and vertical axis.

source

set_expand_horizontally!

set_expand_vertically!

set_extra_widget!

Mousetrap.set_extra_widget!Function
set_extra_widget!(::AlertDialog, ::Widget)

Insert a widget into the dialog's content area, it will be displayed underneath the detailed message.

source

set_file!

set_file_chooser_action!

Mousetrap.set_file_chooser_action!Function
set_file_chooser_action!(::FileChooser, ::FileChooserAction)

Override the current file chooser action type, this may not change the layout until the dialog is hidden, then shown again.

source

set_fixed_width!

Mousetrap.set_fixed_width!Function
set_fixed_width!(::ColumnViewColumn, width::AbstractFloat)

Set the fixed width of the column, in pixels, or -1 if unlimited.

source

set_focus_on_click!

set_focus_visible!

Mousetrap.set_focus_visible!Function
set_focus_visible!(::Window, ::Bool) 

Set whether which widget currently holds input focus should be highlighted using a border.

source

set_fraction!

Mousetrap.set_fraction!Function
set_fraction!(::ProgressBar, zero_to_one::AbstractFloat) 

Set the currently displayed fraction of the ProgressBar, in [0, 1].

source

set_fullscreen!

set_function!

Mousetrap.set_function!Function
set_function!(f, action::Action, [::Data_t]) 

Register a callback that should be called when the action is activated.

Example

action = Action("example.action")
set_function!(action) do x::Action
    println(get_id(x) * " called")
end
source

set_has_base_arrow!

Mousetrap.set_has_base_arrow!Function
set_has_base_arrow!(::Popover, ::Bool) 

Set whether the "tail" of the popover pointing to widget it is attached to should be visible.

source

set_has_border!

set_has_close_button!

set_has_frame!

Mousetrap.set_has_frame!Function
set_has_frame!(::Button, ::Bool) 
set_has_frame!(::Viewport, ::Bool) 
set_has_frame!(::Entry, ::Bool) 
set_has_frame!(::PopoverButton, ::Bool) 

Set whether the widget's outline should be displayed. This does not impact the widget's interactability.

source

set_has_origin!

Mousetrap.set_has_origin!Function
set_has_origin!(::Scale, ::Bool)

Set whether the area of the slider between the start of the range and the current value should be filled with a color.

source

set_has_wide_handle!

set_header_menu!

Mousetrap.set_header_menu!Function
set_header_menu!(::ColumnViewColumn, model::MenuModel) 

Add a menu model to be used as the column's header menu, which the user can access by clicking the column's title.

source

set_hide_on_close!

Mousetrap.set_hide_on_close!Function
set_hide_on_close!(::Window, ::Bool) 

If set to to true, the window will be hidden when it is closed, if set to false, the window is destroyed when closed. false by default.

If set to true, the caller of this function is responsible for deallocating the window by calling destroy!.

source

set_hide_on_overflow!

Mousetrap.set_hide_on_overflow!Function
set_hide_on_overflow!(::Widget, ::Bool) 

Set whether the entire widget should be hidden if its allocated area is smaller than its natural size. If false, the overflow part of the widget will be truncated.

source

set_homogeneous!

set_horizontal_alignment!

set_horizontal_scrollbar_policy!

set_icon!

Mousetrap.set_icon!Function
set_icon!(::Button, ::Icon) 
set_icon!(::ToggleButton, ::Icon)
set_icon!(::PopoverButton, ::Icon)

Replace the button's label with an icon.

source

set_image!

set_initial_file!

Mousetrap.set_initial_file!Function
set_initial_file!(::FileChooser, ::FileDescriptor)

For FILE_CHOOSER_ACTION_OPEN_FILE or FILE_CHOOSER_ACTION_OPEN_MULTIPLE_FILES, choose the file that is selected when the dialog is first shown.

source

set_initial_filter!

Mousetrap.set_initial_filter!Function
set_initial_filter!(::FileChooser, ::FileFilter)

Set currently selected filter. If the filter was not yet added with add_filter!, it will still be made the active filter, but the user will be unable to change the filter selection.

source

set_initial_folder!

Mousetrap.set_initial_folder!Function
set_initial_folder(::FileChooser, ::FileDescriptor)

For FILE_CHOOSER_ACTION_SELECT_FOLDER or FILE_CHOOSER_ACTION_OPEN_MULTIPLE_FOLDERS, choose the folder that is selected when the dialog is first shown.

source

set_initial_name!

Mousetrap.set_initial_name!Function
set_initial_name!(::FileChooser, ::String)

For FILE_CHOOSER_ACTION_SAVE, set the name field that will be used to determine the saved file's name.

source

set_inverted!

Mousetrap.set_inverted!Function
set_inverted!(::LevelBar, ::Bool) 

Set whether the level bar should be mirrored along the horizontal or vertical axis, depending on orientation.

source

set_is_active!

Mousetrap.set_is_active!Function
set_is_active!(::Switch, ::Bool) 
set_is_active!(::ToggleButton, ::Bool) 
set_is_active!(::CheckMark, ::Bool)

Set the internal state of the widget.

source

set_is_circular!

Mousetrap.set_is_circular!Function
set_is_circular!(::Button, ::Bool) 
set_is_circular!(::ToggleButton, ::Bool) 
set_is_circular!(::PopoverButton, ::Bool) 

Set whether the button should be circular, as opposed to rectangular.

source

set_is_decorated!

set_is_expanded!

set_is_focusable!

Mousetrap.set_is_focusable!Function
set_is_focusable!(::Widget, ::Bool) 

Set whether the widget can retrieve input focus. Most widgets that support interaction by default are already focusable.

source

set_is_high_priority!

Mousetrap.set_is_high_priority!Function
set_is_high_priority!(::PopupMessage, high_priority::Bool)

Set whether this message should be shown before any other non-high-priority messages already queue with the PopupMessageOverlay. false by default.

source

set_is_horizontally_homogeneous!

set_is_inverted!

set_is_modal!

Mousetrap.set_is_modal!Function
set_is_modal!(::Window, ::Bool) 
set_is_modal!(::FileChooser, ::Bool) 
set_is_modal!(::ColorChooser, ::Bool) 
set_is_modal!(::AlertDialog, ::Bool) 

Set whether all others windows should be paused while this window is active.

source

set_is_resizable!

set_is_revealed!

Mousetrap.set_is_revealed!Function
set_is_revealed!(::Revealer, child_visible::Bool) 
set_is_revealed!(::ActionBar, widget_visible::Bool) 

Set whether widget or its children should be visible. If the visibility changes, an animation is played.

source

set_is_reversed!

Mousetrap.set_is_reversed!Function
set_is_reversed!(::Animation, is_reversed::Bool)

If set to false, the animation will interpolate its value from the lower to upper bound, or the other way around if true. false by default.

source

set_is_scrollable!

Mousetrap.set_is_scrollable!Function
set_is_scrollable!(::Notebook, ::Bool) 

Set whether the user can scroll between pages using the mouse scroll wheel or touchscreen.

source

set_is_selectable!

Mousetrap.set_is_selectable!Function
set_is_selectable!(::Label, ::Bool) 

Set whether the user can select part of the label, as would be needed to copy its text. false by default.

source

set_is_spinning!

set_is_vertically_homogeneous!

set_is_visible!

Mousetrap.set_is_visible!Function
set_is_visible!(::Widget, ::Bool) 

Set whether the widget is hidden.


set_is_visible!(::Shape, ::Bool) 

Set whether the shape and any associated render tasks should be rendered.


set_is_visible!(::ColumnViewColumn, ::Bool) 

Temporarily remove the column and all its rows from the column view.

source

set_justify_mode!

Mousetrap.set_justify_mode!Function
set_justify_mode!(::Label, mode::JustifyMode) 
set_justify_mode!(::TextView, mode:JustifyMode) 

Set the text justification mode.

source

set_kinetic_scrolling_enabled!

Mousetrap.set_kinetic_scrolling_enabled!Function
set_kinetic_scrolling_enabled!(::Viewport, ::Bool) 
set_kinetic_scrolling_enabled!(::ScrollEventController, ::Bool)

Set whether scrolling should continue once the user stopped operating the mouse wheel or touchscreen, simulating "inertia".

source

set_label_widget!

set_label_x_alignment!

set_layout!

Mousetrap.set_layout!Function
set_layout!(::HeaderBar, layout::String) 

Set layout string of the header bar.

This is a list of button IDs. Valid IDs are limited to:

  • maximize: Maximize Button
  • minimize: Minimize Button
  • close: Close Button

Any object left of : will be placed left of the title, any after : will be place right of the title. Object are delimited by ,.

Example

```julia headerbar = HeaderBar() setlayout!(header_bar, "close:maximize,minimize")

source

set_left_margin!

Mousetrap.set_left_margin!Function
set_left_margin!(::TextView, margin::AbstractFloat) 

Set distance between the left end of the text and the TextView's frame.

source

set_listens_for_shortcut_action!

Mousetrap.set_listens_for_shortcut_action!Function
set_listens_for_shortcut_action!(::Widget, ::Action)

Adds the action to the widget's internal ShortcutEventController. While the widget holds focus, if the user presses the action's associated shortcut, the action will trigger.

source

set_log_file!

Mousetrap.set_log_file!Function
set_log_file!(path::String) -> Bool

Set file at path as the log file. Any logging will be pushed to the file as opposed to being printed to the console. The file will be created if it does not exist. If it does exist, the file will be appended to, as opposed to being overwritten.

Returns true if the file was successfuly opened.

source

set_lower!

Mousetrap.set_lower!Function
set_lower!(::Adjustment, ::Number) 
set_lower!(::Scale, ::Number) 
set_lower!(::SpinButton, ::Number) 
set_lower!(::Animation, ::Number)

Set lower bound of the underlying range.

source

set_margin!

Mousetrap.set_margin!Function
set_margin!(::Widget, margin::AbstractFloat) 

Set both the left, right, top, and bottom margin of the widget, in pixels.

source

set_margin_bottom!

Mousetrap.set_margin_bottom!Function
set_margin_bottom!(::Widget, margin::AbstractFloat) 

Set distance between the bottom of the text and the TextView's frame, in pixels.

source

set_margin_end!

set_margin_horizontal!

set_margin_start!

set_margin_top!

set_margin_vertical!

set_max_n_columns!

Mousetrap.set_max_n_columns!Function
set_max_n_columns!(grid_view::GridView, n::Integer) 

Limit the number of columns (or rows, if horizontal) to given number, or -1 if unlimited.

source

set_max_value!

set_max_width_chars!

Mousetrap.set_max_width_chars!Function
set_max_width_chars!(::Label, n::Integer) 
set_max_width_chars!(::Entry, n::Integer) 

Set the number of characters that the widget should make space for, or -1 if unlimited.

source

set_maximized!

set_maximum_size!

Mousetrap.set_maximum_size!Function
set_maximum_size!(::ClampFrame, size::AbstractFloat)

Set the maximum width (or height, if vertical) the frame should constrain its child to, in pixels.

source

set_message!

Mousetrap.set_message!Function
set_message!(::AlertDialog, ::String)

Set the main message of the dialog, this will be used as the dialogs title.

source

set_min_n_columns!

set_min_value!

set_minimized!

set_mode!

Mousetrap.set_mode!Function
set_mode!(::LevelBar, mode::LevelBarMode) 

Set whether the level bar should display its value continuous or segmented.

source

set_n_digits!

Mousetrap.set_n_digits!Function
set_n_digits!(::SpinButton, n::Integer) 

Set number of digits after the decimal point, up to a maximum of 20. This only affects the visuals of the SpinButton, the internal value of the underlying adjustment is unaffected.

source

set_only_listens_to_button!

Mousetrap.set_only_listens_to_button!Function
set_only_listens_to_button!(::SingleClickGesture, button::ButtonID) 

Set which mouse buttons the event controller should listen to, or BUTTON_ID_ANY to listen to all buttons.

source

set_opacity!

set_orientation!

Mousetrap.set_orientation!Function
set_orientation!(::Box, ::Orientation) 
set_orientation!(::FlowBox, ::Orientation)
set_orientation!(::CenterBox, ::Orientation) 
set_orientation!(::ClampFrame, ::Orientation)
set_orientation!(::LevelBar, ::Orientation) 
set_orientation!(::Grid, ::Orientation) 
set_orientation!(::ProgressBar, ::Orientation) 
set_orientation!(::Scrollbar, ::Orientation) 
set_orientation!(::Separator, ::Orientation) 
set_orientation!(::ListView, ::Orientation) 
set_orientation!(::GridView, ::Orientation) 
set_orientation!(::Paned, ::Orientation) 
set_orientation!(::SpinButton, ::Orientation)
set_orientation!(::Scale, ::Orientation)

Set orientation of the widget, this governs along which axis it aligns itself and its children.


set_orientation!(::PanEventController) 

Set along which axis the event controller should listen for pan gestures.

source

set_pixel!

Mousetrap.set_pixel!Function
set_pixel!(image::Image, x::Integer, y::Integer, color::RGBA) 
set_pixel!(image::Image, x::Integer, y::Integer, color::HSVA) 

Override the color of a pixel, 1-based indexing.

source

set_popover!

Mousetrap.set_popover!Function
set_popover!(::PopoverButton, popover::Popover) 

Attach a Popover to the popover button. This will detach any already attached Popover or PopoverMenu.

source

set_popover_menu!

Mousetrap.set_popover_menu!Function
set_popover_menu!(popover_button::PopoverButton, popover_menu::PopoverMenu) 

Attach a PopoverMenu to the popover button. This will detach any already attached Popover or PopoverMenu.

source

set_position!

Mousetrap.set_position!Function
set_position!(::Paned, position::Integer) 

Set position of the paned handle, relative to the Paned's origin, in pixels.

source

set_primary_icon!

set_propagate_natural_height!

set_propagate_natural_width!

set_propagation_phase!

Mousetrap.set_propagation_phase!Function
set_propagation_phase!(controller::EventController, ::PropagationPhase) 

Set the phase at which the event controller will capture events, see here for more information.

source

set_quick_change_menu_enabled!

set_ratio!

set_relative_position!

Mousetrap.set_relative_position!Function
set_relative_position!(::Popover, position::RelativePosition) 
set_relative_position!(::PopoverButton, position::RelativePosition) 

Set position of the popover relative to the widget it is attached to.

source

set_repeat_count!

Mousetrap.set_repeat_count!Function
set_repeat_count!(::Animation, ::Unsigned)

Set the number of cycles the animation should perform, or 0 if the animation loops endlessly. 1 by default.

source

set_resource_path!

set_right_margin!

Mousetrap.set_right_margin!Function
set_right_margin!(::TextView, margin::AbstractFloat) 

Set margin between the right end of the text and the TextView's frame.

source

set_row_spacing!

Mousetrap.set_row_spacing!Function
set_row_spacing!(::Grid, spacing::Number) 
set_row_spacing!(::FLowBox, spacing::Number)

Set spacing between rows of the grid, in pixels.

source

set_rows_homogeneous!

set_scale!

Mousetrap.set_scale!Function
set_scale!(::ImageDisplay, scale::Integer) 

Scale image by a constant factor, in {1, 2, 3, ...}.

source

set_scale_mode!

Mousetrap.set_scale_mode!Function
set_scale_mode!(texture:TextureObject, ::TextureScaleMode) 

Set the OpenGL scale mode the texture uses, TEXTURE_SCALE_MODE_NEAREST by default.

source

set_scope!

Mousetrap.set_scope!Function
set_scope!(::ShortcutEventController, scope::ShortcutScope) 

Set the scope in which the controller listens for shortcut events, see here for more information.

source

set_scrollbar_placement!

set_secondary_icon!

set_selected!

Mousetrap.set_selected!Function
set_selected!(::DropDown, id::DropDownItemID)

Make the item identified by the given ID the currently selected item. This will invoke its associated callback.

source

set_should_draw_value!

set_should_interpolate_size!

set_should_snap_to_ticks!

Mousetrap.set_should_snap_to_ticks!Function
set_should_snap_to_ticks!(::SpinButton, ::Bool) 

Set whether when the user enters a value using the spin buttons text entry, that value should be clamped to the nearest tick.

source

set_should_wrap!

Mousetrap.set_should_wrap!Function
set_should_wrap!(::SpinButton, ::Bool) 

Set whether the spin button should over- / underflow when reaching the upper or lower end of its range.

source

set_show_column_separators

set_show_row_separators

set_show_separators!

set_show_text!

Mousetrap.set_show_text!Function
set_show_text!(::ProgressBar, ::Bool)

Set whether a percentage or custom text should be displayed above the ProgressBar. Use set_text! to specify the custom text.

source

set_show_title_buttons!

set_signal_activate_blocked!

Mousetrap.set_signal_activate_blocked!Function
set_signal_activate_blocked!(::T, ::Bool)

If set to true, blocks emission of this signal until turned back on, where T is a signal emitter that supports signal activate.

source

set_signal_activate_default_widget_blocked!

set_signal_activate_focused_widget_blocked!

set_signal_activate_item_blocked!

set_signal_activated_blocked!

Mousetrap.set_signal_activated_blocked!Function
set_signal_activated_blocked!(::T, ::Bool)

If set to true, blocks emission of this signal until turned back on, where T is a signal emitter that supports signal activated.

source

set_signal_button_clicked_blocked!

set_signal_click_pressed_blocked!

set_signal_click_released_blocked!