• Getting Started
  • Installing Storm
  • Running Storm
    • Bundled Programs
    • In the Terminal
    • The Top Loop
    • Getting Help
    • External Code
  • Developing in Storm
    • Source References
    • Compilation Model
    • Compile from Source
    • Emacs Integration
  • Tutorials
    • Fundamentals
    • Values and Classes
    • Threading
    • Files and Streams
    • Serialization
    • UI
    • Tests
    • Using Grammar
    • New Expressions
      • Repeat Using AST
      • Repeat Using IR
      • Map Using AST
      • Map Using IR
    • New Entities
    • New Languages
    • Libraries in C++
• Language Reference
  • Storm
    • Threading Model
    • Type System
    • The Name Tree
    • Exceptions
    • Compilation Model
    • Packages and Files
    • Top Loop
    • Command Line
    • Language Server
      • Emacs Plugin
      • Protocol
      • Languages
  • Basic Storm
    • Names
    • Comments
    • Definitions
      • Functions
      • Types
      • Enumerations
      • Global Variables
      • Named Threads
      • Generators
    • Code
      • Literals
      • Variables
      • Blocks
      • Function Calls
      • Function Return
      • Operators
      • Conditionals
      • Loops
      • Maybe and Null
      • Exceptions
      • Type Conversions
      • Function Objects
    • Extensibility
      • Expressions
      • Blocks
      • Metaprogramming
  • The Syntax Language
    • Terminology
    • Names
    • Visibility
    • Grammar
    • The Parse Tree
    • Syntax Transforms
    • Syntax Highlighting
    • Indentation
    • The Info Tree
  • Intermediate Language
    • Type Descriptions
    • Listings
    • Sizes and Offsets
    • References
    • Operands
    • Instructions
    • Binary Objects
    • Example
  • C++
    • Compilation
    • Annotations
    • Objects
    • Threading
    • Debugging
• Library Reference
  • Standard Library
    • Primitive Types
    • Objects and Actors
    • Strings
    • Containers
    • Iterators
    • Maybe
    • Variant
    • Function Objects
    • Exceptions
    • Copying Objects
    • IO
      • Url
      • Buffers
      • Streams
      • Text IO
      • Standard Streams
      • Networking
      • Other Streams
      • Serialization
    • Threading
    • Geometry
    • Graphics
    • Time
    • System Interfaces
    • Stack Traces
    • Unknown Types
    • Unsafe Operations
  • Compiler Library
    • The Value Type
    • Named Entities
    • Parsing
    • Code Generation
  • Unit Tests
  • Parser Library
  • Sound Library
  • Graphics Library
  • Layout Library
  • UI Library
    • Windows
    • Layout
    • Rendering
  • Presentation Library
    • Presentations
    • Layout
    • Elements
    • Animations
    • Picture Elements
  • Crypto Library
  • Markdown Library
    • Markdown
    • Usage
    • Documentation
      • The Storm Theme
  • SQL Library
    • Database Interface
    • Language Extension
  • Inline Assembler
    • Syntax
• Programs
  • Progvis
  • Tree Tool
• Downloads
  • Release Notes

Graphics Library

The external graphics library is a complement to the types in the standard library. It provides the ability to load and save images from a number of common file formats.

The graphics library is located in the package graphics, and entirely implemented in a single shared library. Since this is an external library, it does not need to be distributed alongside applications where it is not needed.

The library provides a convenient API for common operations. This API consists of the following functions:

• graphics.Image loadImage(core.io.IStream from)

  Load an image from a core.io.IStream. The function inspects the first few bytes of the image to determine its format. For this reason, the stream needs to support peeking around 10 bytes from the current location and onwards.

  Throws an graphics.ImageLoadError on failure.

• graphics.Image loadImage(core.io.Url file)

  Wrapper to load a file from an Url. Equivalent to calling loadImage(file.read()), but checks that the file exists before attempting to open it in order to generate better error messages.

• void saveImage(graphics.Image image, core.io.Url file)

  Save an image to a file. The library uses the extension of the file name to select an appropriate decoder and save the file.

The library also provides a more advanced API for more control over the process. This API centers around the type graphics.ImageFormat, which represents an image format. You can then call the options member to create an graphics.FormatOptions instance that lets you either load a file and inspect the settings used to compress the file, or to set the settings and then save an image using those.

The library has the following functions for listing image formats:

• core.Array<graphics.ImageFormat> supportedImageFormats()

  This function returns an array of all supported image formats. This makes it possible to enumerate all currently supported formats, for example to use in a file selection dialog.

• void registerImageFormat(graphics.ImageFormat format)

  Allows registering custom image formats with the library so that other parts of the system may use them.

• core.Maybe<graphics.ImageFormat> findFormat(core.io.IStream from)

  Select a format that can decompress the image in the stream by inspecting its header. This is what loadImage described above uses to decompress images.

• core.Maybe<graphics.ImageFormat> findFormat(core.Str fileExt)

  Select a format that is suitable for the file extension (case insensitive) passed to the function. This is what saveImage above uses.

On Linux, the graphics library uses libpng for decoding PNG images, and libjpegturbo for JPEG images. On Windows, the Windows Imaging API is used. BMP and PPM use custom implementations that support the most common image types. For example, this means that compressed BMP formats will not work.

© 2017-2025 Filip Strömbäck

Design by Christoffer Holm