API Reference

Enum representing the state of a mouse button.

• IsReleased: The button is currently released.
• IsPressed: The button is currently pressed.

Represents the position of a cursor in the editor.

• line: Line number (1-based)
• column: Column number (1-based, character position within the line)

Create a new EditorState with the given text and language.

State for the code editor containing text, cursor position, and cached tokenization.

• text: The full text content
• cursor: Current cursor position
• is_focused: Whether the editor is focused
• cached_lines: Cache of tokenized line data
• text_hash: Hash of the text to detect changes

Create a new EditorState with updated text, preserving cursor and focus state from the old state.

Create a new EditorState with updated focus state, preserving text and cursor from the old state.

Struct representing a keyboard event.

• key: GLFW key code (e.g., GLFW.KEYA, GLFW.KEYENTER)
• scancode: Hardware-specific scancode
• action: GLFW action (GLFW.PRESS, GLFW.RELEASE, GLFW.REPEAT)
• mods: Modifier key flags (GLFW.MODSHIFT, GLFW.MODCONTROL, etc.)

Cached tokenization data for a line of code.

• line_number: The line number this data belongs to
• line_text: The original line text
• tokens: Vector of tokens for this line
• token_data: Processed token data with positions and colors

Enum representing the different mouse buttons.

• LeftButton: The left mouse button.
• RightButton: The right mouse button.
• MiddleButton: The middle mouse button (scroll button).

Abstract type for views that have constrained/intrinsic sizing behavior. These views know their preferred dimensions and can be used with alignment components. Examples: IntrinsicSize, FixedSize, IntrinsicWidth, IntrinsicHeight, etc.

AlignHorizontal(child::SizedView, alignment::Symbol)

Aligns a sized child component horizontally within its container.

Arguments

• child: A SizedView component that has intrinsic dimensions
• alignment: Horizontal alignment (:left, :center, :right)

Example

AlignHorizontal(IntrinsicSize(Image("logo.png")), :left)
AlignHorizontal(FixedSize(Text("Hello"), 100.0f0, 50.0f0), :right)

AlignVertical(child::SizedView, alignment::Symbol)

Aligns a sized child component vertically within its container.

Arguments

• child: A SizedView component that has intrinsic dimensions
• alignment: Vertical alignment (:top, :center, :bottom)

Example

AlignVertical(IntrinsicSize(Image("logo.png")), :top)
AlignVertical(FixedSize(Text("Hello"), 100.0f0, 50.0f0), :center)

The Container is the most basic GUI component that can contain another component. It is the most basic building block of the GUI system.

FixedSize(child::AbstractView, width::Real, height::Real)

Creates a view that has a fixed size, regardless of the child's intrinsic size. The child will be rendered at the specified width and height.

A button consisting of the icon only.

IntrinsicSize(child::AbstractView=EmptyView())

The IntrinsicSize component is used to wrap a child view and ensure that it uses its intrinsic size for layout. This is useful for components that should not stretch to fill their parent container, but rather use their natural size.

A button containing text only.

Apply clipboard action (placeholder for now).

Apply delete text action.

Apply an editor action to the editor state.

Apply text insertion action.

apply_layout(component::AbstractView)

Apply layout to a GUI component and its children. This function calculates and applies the layout to components. The interpret_view function then uses the positions and sizes calculated by this function.

Apply cursor movement action.

Alternative signature in case GLFW passes Char directly This function adds a character directly to the key buffer.

New character callback for proper text input This function handles character input from the keyboard, converting Unicode codepoints to characters.

Delete text between two cursor positions.

Detect click events and handle focus and cursor positioning.

Detect click events and handle focus and cursor positioning for TextBox.

draw_closed_lines(vertices::Vector{Point2f}, color_rgba::Vec4{<:AbstractFloat})

Draw closed lines using the provided vertices and color.

Draw the cursor at the specified position.

draw_rectangle(vertices::Vector{Point2f}, color_rgba::Vec4{<:AbstractFloat}, projection_matrix::Mat4{Float32})

Draw a rectangle using the provided vertices and color.

draw_rounded_rectangle(
    vertices::Vector{Point2f},
    width::Float32, height::Float32,
    fill_color_rgba::Vec4{<:AbstractFloat}, border_color_rgba::Vec4{<:AbstractFloat},
    border_width::Float32, radius::Float32,
    projection_matrix::Mat4{Float32}
)

Draw a rounded rectangle with border using the custom shader.

Ensure tokenization data is cached for the given line.

Find word boundary for word-based movement.

generate_rectangle_vertices(x, y, width, height)

Function to generate a rectangle with specified position and size in pixel coordinates.

This function creates a rectangle defined by its top-left corner (x, y), width, and height.

Get the lines of text from the editor state.

get_orthographic_matrix(left::T, right::T, bottom::T, top::T, near::T, far::T)::Matrix{T} where {T<:Real}

Create an orthographic projection matrix.

Handle key input for TextBox (same as CodeEditor but without syntax highlighting).

Initialize the shader program (must be called after OpenGL context is created)

interpret_view(component::AbstractView, x::Float32, y::Float32, width::Float32, height::Float32, projection_matrix::Mat4{Float32})

Interpret the view of a GUI component. This function is responsible for interpreting the view of a GUI component based on its layout and properties.

Convert a GLFW key event to an EditorAction.

Render a line using cached tokenization data.

run(ui_ref[]::AbstractView; title::String="Fugl", window_width_px::Integer=1920, window_height_px::Integer=1080)

Run the main loop for the GUI application. This function handles the rendering and event processing for the GUI.

Tokenize a Julia line and return tokens with color data. Returns (tokens, tokendata) where tokendata is [(position, text, color), ...]

Tokenize a line of code and return tokens with color data. Returns (tokens, tokendata) where tokendata is [(position, text, color), ...]

Update the text in the editor state and invalidate caches if needed.