Can `ImageInTerminal.disable_encoding()` propagate to third-party packages?

[jwortmann]

This package defines Base.displayable for the ::TerminalGraphicDisplay with MIME image/png:

ImageInTerminal.jl/src/display.jl

Lines 7 to 11 in 6d2390b

	Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", x::Any) =
	showable("image/png", x)
	Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", ::Vector{UInt8}) = true
	Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", ::AbstractArray{<:Colorant}) =
	true

The README mentions rendering for Colorant and for Latexify.jl, but we can also use it in a third-party package MyPackage to render custom types in form of an image if ImageInTerminal is loaded. For example:

module MyPackage

import Sixel

const SIXEL_SUPPORTED = Ref(false)

struct MyType end

# Base.summary(io::IO, x::MyType) = ...

function Base.show(io::IO, ::MIME"text/plain", x::MyType)
    println(io, summary(x), ":")
    # only render as image if terminal has Sixel support
    if SIXEL_SUPPORTED[] && displayable("image/png")
        display("image/png", x)
    else
        # println(...)
    end
end

function Base.show(io::IO, ::MIME"image/png", x::MyType)
    # ...
end

__init__() = SIXEL_SUPPORTED[] = Sixel.is_sixel_supported()

end

However, ImageInTerminal also defines functions disable_encoding() and enable_encoding() to toggle image rendering on/off during runtime. Currently there is no way for MyPackage to know whether the user has toggled image rendering, and therefore calling ImageInTerminal.disable_encoding() has no effect for the code shown above. I wonder whether the current state should be reflected in displayable, like this (here only the first line seems relevant for third-party packages):

Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", x::Any) = SHOULD_RENDER_IMAGE[] && showable("image/png", x)
Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", ::Vector{UInt8}) = SHOULD_RENDER_IMAGE[]
Base.displayable(::TerminalGraphicDisplay, ::MIME"image/png", ::AbstractArray{<:Colorant}) = SHOULD_RENDER_IMAGE[]

What do you think?

---

Edit: Actually I just realized that in the code above I call only displayable("image/png"), without the x::MyType, and the solution suggested here doesn't work. I'll try to find out where the single-argument displayable comes from and how it relates to the methods that are defined in this package (loading ImageInTerminal does have an effect for the single-argument displayable("image/png")).

Edit 2: Okay, I found it at https://github.com/JuliaLang/julia/blob/3076a9683609b5c587ae3cbc70b25b7332018c7f/base/multimedia.jl#L364-L372
In particular displayable("image/png") only checks if there is a method display("image/png", x::Any) defined for any display in the display stack. Indeed it is defined at

ImageInTerminal.jl/src/display.jl

Line 13 in 6d2390b

function Base.display(d::TerminalGraphicDisplay, ::MIME"image/png", x::Any)

This means that displayable("image/png") will unconditionally always return true if ImageInTerminal is loaded, and I will need to think of another way how the ImageInTerminal.disable_encoding() could propagate to third-party packages.

[johnnychen94]

In particular displayable("image/png") only checks if there is a method display("image/png", x::Any) defined for any display in the display stack.

My memory (might be wrong) tells me that there are two stages of display controls: 1) choose what are the potential display backends, 2) loop over all the potential displays, and use the first displayable to display.
This displayable("image/png") returns true only affects the first stage, but during the second stage, ImageInTerminal's displayable should still work as expected.

---

Does https://github.com/JuliaPlots/Plots.jl/blob/v2/PlotsBase/ext/ImageInTerminalExt.jl help?

(Sorry that I don't have too much bandwidth to proceed with open source recently, but I'd be very happy to merge PRs if there were)

[jwortmann]

Does https://github.com/JuliaPlots/Plots.jl/blob/v2/PlotsBase/ext/ImageInTerminalExt.jl help?

Thanks for the response and for pointing me into the right direction. I haven't worked with package extensions before, but this looks like it is exactly what I need. I think it should be possible to define a new display method for the TerminalGraphicDisplay and my custom type in a package extension, without the need to have ImageInTerminal or Sixel as a regular dependency of my package. This seems like a better approach than trying to "hack" something into displayable.

I think we can close this issue, as it is not really an issue with ImageInTerminal.

[jwortmann]

Just for reference, the following code as a package extension (in a third-party package) allows to render a custom type MyType from a package MyPackage as an image, provided that the terminal supports Sixel graphics and that the user has loaded the ImageInTerminal package. In other words, it extends the functionality of ImageInTerminal that is built-in for Colorant / AbstractArray{<:Colorant} to any other custom type, for which rendering in form of an image would be useful. Furthermore it respects the user toggle via ImageInTerminal.disable_encoding() / ImageInTerminal.enable_encoding().

This code assumes that in MyPackage you have defined methods for

Base.summary(io::IO, x::MyType)
Base.show(io::IO, ::MIME"text/plain", x::MyType)
Base.show(io::IO, ::MIME"image/png", x::MyType)

---

File MyPackage.jl/ext/ImageInTerminalExt.jl:

module ImageInTerminalExt

using MyPackage
import ImageInTerminal


function Base.show(io::IOContext, mime::MIME"text/plain", x::MyType)
    if ImageInTerminal.ENCODER_BACKEND[] == :Sixel && ImageInTerminal.SHOULD_RENDER_IMAGE[]
        println(io, summary(x), ":")
        display("image/png", x)
    else
        invoke(Base.show, Tuple{IO, typeof(mime), MyType}, io, mime, x)
    end
end

end

It works because IOContext is more specific than IO, so this method takes precedence whenever ImageInTerminal is loaded. Not sure if there is a better approach, but this seems to work well for me.