Layout

Padding

Stores information about ammount of padding.

mutable struct PlaceHolder <: AbstractLayoutElement
    segments::Vector{Segment}
    measure::Measure
end

A renderable used as a place holder when creating layouts (e.g. with grid).

Examples

println(PlaceHolder(25, 10))

╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ 
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ 
╲ ╲ ╲ (25 × 10) ╲ ╲ ╲ ╲
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ 
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ 
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲
╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ ╲ 

PlaceHolder(
    h::In,
    w::Int;
    style::String = "dim",
    text::Union{Nothing,String} = nothing,
)

Create a PlaceHolder with additional style information.

    Spacer

A box of empty text with given width and height.

hLine

A 1-line renderable made of repeated character from a Box.

hLine(text::AbstractString; style::Union{String, Nothing}=nothing, box::Symbol=TERM_THEME[].box)

Construct an hLine as wide as the stdout with centered text.

hLine(width::Number, style::Union{String, Nothing}; box::Symbol=TERM_THEME[].box)

Create a styled hLine of given width.

hLine(width::Number, text::String; style::Union{String, Nothing}=nothing, box::Symbol=TERM_THEME[].box)

Creates an hLine object with texte centered horizontally.

hLine(ren::AbstractRenderable; kwargs)

Construct an hLine with same width as a renderable.

hLine(; style::Union{String, Nothing}=nothing, box::Symbol=TERM_THEME[].box)

Construct an hLine as wide as the stdout.

vLine

A multi-line renderable with each line made of a | to create a vertical line.

vLine(
    height::Int;
    style::String = TERM_THEME[].line,
    box::Symbol = TERM_THEME[].box,
    char::Union{Char,Nothing} = nothing,
)

Create a vLine given a height and, optionally, style information.

vLine(ren::AbstractRenderable; kwargs...)

Construct a vLine with the same height as a renderable.

vLine(; style::Union{String, Nothing}=nothing, box::Symbol=:ROUNDED)

Create a vLine as tall as the stdout console.

center!(renderables::RenderablesUnion... )

In place version of center.

Examples

p1 = Panel(; width=25)
p2 = Panel(; width=50)
center!(p1, p2)
print(p1/p2)

             ╭───────────────────────╮             
             ╰───────────────────────╯             
╭────────────────────────────────────────────────╮
╰────────────────────────────────────────────────╯

center(renderables::RenderablesUnion... )

Pad two (or more) renderables so that they have the same width and they are centered.

NOTE: the renderables returned have different type and potentially different size from the inputs

Examples

p1 = Panel(; width=25)
p2 = Panel(; width=50)
p1, p2 = center(p1, p2)
print(p1/p2)

             ╭───────────────────────╮             
             ╰───────────────────────╯             
╭────────────────────────────────────────────────╮
╰────────────────────────────────────────────────╯

lvstack(renderables::RenderablesUnion...)

Center align renderables and then vertically stack.

hstack(renderables...)

Horizonatlly stack a variable number of renderables.

hstack(r1::RenderablesUnion, r2::RenderablesUnion   )

Horizontally stack two renderables to give a new renderable.

leftalign!(renderables::RenderablesUnion...)

In place version of leftalign.

Examples

```julia p1 = Panel(; width=25) p2 = Panel(; width=50) leftalign!(p1, p2) print(p1/p2)

╭───────────────────────╮ ╰───────────────────────╯ ╭────────────────────────────────────────────────╮ ╰────────────────────────────────────────────────╯

leftalign(renderables::RenderablesUnion...)

Pad two (or more) renderables so that they have the same width and they are left-aligned.

NOTE: the renderables returned have different type and potentially different size from the inputs

Examples

p1 = Panel(; width=25)
p2 = Panel(; width=50)
p1, p2 = leftalign(p1, p2)
print(p1/p2)


╭───────────────────────╮                         
╰───────────────────────╯                         
╭────────────────────────────────────────────────╮
╰────────────────────────────────────────────────╯

lvstack(renderables::RenderablesUnion...)

Left align renderables and then vertically stack.

pad(text::AbstractString, left::Int = 0, right::Int = 0)

Pad a string by a fixed ammount to the left and to the right.

pad(segments::AbstractVector{Segment}, left::Int = 0, right::Int = 0)

Pad a renderable's segments to the left and the right.

pad(s::Segment, left::Int = 0, right::Int = 0; kwargs...)

Pad a segment.

pad!(ren::AbstractRenderable, left::Int, right::Int)

In place version for padding a renderable.

pad!(ren::AbstractRenderable; width::Int)

In place version for padding a renderable to achieve a given width.

function pad(text::AbstractString, target_width::Int, method::Symbol, lw::Int; bg = nothing)::String

complete string padding but knowing line width of the string. Useful in cases the line width needs to be enforced instead of obtained through width(text), e.g. when paddnig a Link's text.

pad(text::AbstractString, target_width::Int, method::Symbol)::String

Pad a string to width: target_width by adding empty spaces strings " ". Where the spaces are added depends on the justification method ∈ (:left, :center, :right, :justify).

Examples

julia> pad("ciao", 10, :left)
"ciao      "

julia> pad("ciao", 10, :center)
"   ciao   "

julia> pad("ciao", 10, :right)
"      ciao"

pad(ren::AbstractRenderable, left::Int, right::Int)

Pad an AbstractRenderable by padding each of its segments.

pad(ren::AbstractRenderable; width::Int)

Pad a renderable to achieve a target width.

Example

julia> pad(RenderableText("ciao"); width=10)
    ciao   

rightalign!(renderables::RenderablesUnion... )

In place version of rightalign.

Examples

p1 = Panel(; width=25)
p2 = Panel(; width=50)
rightalign!(p1, p2)
print(p1/p2)

                         ╭───────────────────────╮
                         ╰───────────────────────╯
╭────────────────────────────────────────────────╮
╰────────────────────────────────────────────────╯

rightalign(renderables::RenderablesUnion... )

Pad two (or more) renderables so that they have the same width and they are right aligned.

NOTE: the renderables returned have different type and potentially different size from the inputs

Examples

p1 = Panel(; width=25)
p2 = Panel(; width=50)
p1, p2 = rightalign(p1, p2)
print(p1/p2)

                         ╭───────────────────────╮
                         ╰───────────────────────╯
╭────────────────────────────────────────────────╮
╰────────────────────────────────────────────────╯

lvstack(renderables::RenderablesUnion...)

Right align renderables and then vertically stack.

vertical_pad(text::AbstractString, above::Int = 0, below::Int = 0)

Vertical pad a string by a fixed ammount to above and below.

vertical_pad(segments::AbstractVector{Segment}, above::Int = 0, below::Int = 0)

Pad a renderable's segments to the above and the below.

verti0cal_pad!(ren::AbstractRenderable, above::Int, below::Int)

In place version for vertically padding a renderable.

pad!(ren::AbstractRenderable; width::Int)

In place version for padding a renderable to achieve a given width.

verticalpad(text, targetheight::Int, method::Symbol)::String

Vertically pad a string to height: target_height by adding empty strings above/below " ". Where the spaces are added depends on the justification method ∈ (:top, :center, :bottom).

vertical_pad(ren::AbstractRenderable, above::Int, below::Int)

Pad a renderable, vertically.

vertical_pad(ren::AbstractRenderable; height::Int)

Vertical pad a renderable to achieve a target height.

vstack(renderables...)

Vertically stack a variable number of renderables to give a new renderable