JUCE Overview

JUCE (Jules' Utility Class Extensions) is an all-encompassing C++ class library for developing cross-platform applications.

It's particularly good for creating highly-specialised user interfaces and for handling graphics and sound.

The intended users are developers like me, who are writing large, complex applications in C++ and who would like to use just one clean, high-level API rather than a bunch of different libraries for different purposes or platforms.

Goals

My main goals with JUCE were to make it:

• Exhaustive - if I'm writing an application I don't want to bother linking to lots of different libraries. There's a core of basic functionality that everyone needs - Java programmers already have the JDK to do all this, and I wanted something similar for C++.
• Literate - class, method and variable names are clear, self-explanatory and written in English rather than abbreviated programmerspeak, to make your code more readable and understandable.
• Coherent - it should be easy to find the right classes for the task you need to do - and when you find them, it should be obvious how they should be used. All parts of the codebase should be written in exactly the same style.
• Multi-platform - just recompile to run on PC, Mac and Linux (and maybe more in the future). There shouldn't be any surprises when you run your code on a different platform - GUIs should be look pixel-for-pixel the same on all machines and should behave the same way.
• Modern C++ - very object-oriented, avoiding macros and older C-style coding wherever possible.

Licence

JUCE is released under the GNU Public Licence, which means it can be freely copied and distributed, and costs nothing to use in open-source applications.

If you'd like to release a closed-source application that uses JUCE, commercial licences are available for a fee - click here for more information on pricing and terms.

Summary of JUCE's features:

There's an awful lot of content in the 150,000 lines of code that make up Juce. Here's an attempt at a list of the main things it can do...

There's also a complete set of API documentation here, where you can browse through all the available classes.

Core Classes

• Large set of powerful container and unicode string classes.
• A comprehensive set of file, directory and stream I/O classes, including streams for memory i/o, buffering and zlib-based compression/decompression.
• A full set of cross-platform threading and multitasking abilities: threads, synchronisation, events, thread-pools, process control, etc.
• A wide-ranging set of messaging classes provides many options for event-based development: listener and broadcaster classes, timers, asynchronous callbacks, inter-application messaging, and much more.
• Many utility functions and classes for data conversion, time and date, atomic operations, maths functions, random numbers, etc.
• Ability to compile only the non-UI classes, for use in writing command-line apps.

User Interface

• A large basic set of components including all the usual suspects: buttons, combo boxes, text editors, listboxes, treeviews, tables, viewports, sliders, tabbed boxes, etc.
• All drawing is flicker-free, using double-buffering on all platforms.
• A look-and-feel system allows the look of various UI elements to be changed dynamically, and customised by an application.
• Windows can use either a Juce platform-independent titlebar and buttons, or the normal platform-specific decorations.
• OpenGL support on all platforms allows openGL components to be embedded inside Juce components. These can be drawn either using the normal Juce paint event, or on their own thread.
• Quicktime support allows Quicktime movies to be embedded and controlled through a platform-independent class. (Not available on Linux, obviously).
• System clipboard support for copying/pasting text.
• Versatile classes for controlling the resizing of components and other objects, doing all the nasty logic involved in resizing either using a stretchable border or a corner-resizer, and allowing custom constraints, fixed aspect ratios, etc
• Alert window classes allow anything from a simple "ok" dialog box to a larger alert box with custom components in it.
• MDI windowing made possible with a multi-document component which can flip between putting its child windows in a tabbed box or as separate floating windows
• Keyboard input can be managed in a range of way, from intercepting keys directly to using a key-mapping set to redirect keystrokes to automatically-invoked application level commands. The keyboard model allows events when keys are pressed and released, and changes to modifier keys.
• Tool-tip support allows tooltips to be done as a floating window, or in any custom style.
• Property components provide a set of components to represent various types of value as sliders, drop-down lists, text, etc These are shown in a list and make a simple way to display a set of properties for a selected object.
• Internal drag-and-drop within the same application allows versatile drag-and-drop logic to be acheived, with effects like semi-transparent icons, snapping back when released, etc.
• External drag-and-drop of files and text can be made to and from other applications.
• Popup menus and menu bars can contain custom components, and can be used to automatically trigger application commands, display appropriate key shortcuts, and much more.
• A set of file-browser components can be used to show either an entire file open/close dialog with embedded preview, or any subset of this, such as a navigable file list.
• Graphic effects like drop-shadows, blurs and glows can be applied to the contents of UI components.
• Other ready-made UI components are included for specialised purposes like splash-screens, editing a set of key-press mappings, choosing audio device settings, selecting colours using a HSV colour picker, a clickable MIDI keyboard, lassoing objects, magnifying or shrinking other components, etc. All of these can be subclassed and customised, of course.
• Drop-shadows are used on Juce top-level windows (where possible and where the OS doesn't already do this itself).

The Jucer

• The Jucer is Juce's UI component builder application. It comes along as part of the Juce source tree.
• Allows Juce components to be designed visually, adding from a palette of standard or custom Juce components.
• Generates ready-to-compile c++ code, with embedded metadata so that the same code can be reloaded and edited again later.
• Allows graphics to be edited as well as sub-components - polygons, shapes and images can be added, with various types of gradient and brush fills applied to them.
• Jucer components can be embedded inside other Jucer components for WYSISYG editing of complex hierarchies.
• Custom component types help to create certain types of component - e.g. the Button editor lets you design the graphics for all the button's up/down/over states.

Graphics

• Image support for 24-bit RGB and 32-bit ARGB images.
• All graphics operations are sub-pixel accurate and anti-aliased. Drawing is platform-independent, and should be almost pixel-for-pixel the same on all platforms.
• Image file formats supported are JPEG, PNG and GIF. JPEG and PNGs can be saved as well as loaded.
• Image loading utilities make it easy to incorporate images in your app: an image cache can be used to store recently used images and avoid keeping multiple copies of the same one; images can be loaded from memory of from any kind of file stream, or just directly from a filename.
• Easy embedding of images into c++ code using either the Jucer or BinaryBuilder makes it simple to add resources in a platform-independent way.
• Geometric paths and shapes can be created and manipulated with the Path class.
• A set of geometric primitives include lines, rectangles, points, rectangular regions, affine transforms, and more.
• Fonts are handled in a platform-independent manner, being rendered internally in Juce, and can be turned into paths for manipulation using affine transforms or other geometric operations.
• Gradient fills can be linear and radial, with any number of intermediate colours
• Image brushes allow shapes to be filled with tiled patterns.
• A set of "drawable" classes allow graphs of drawable elements (e.g. paths, text, images) to be built up and drawn as a unit.
• Importer for simple SVG files, which converts them into juce Drawable objects ready for further manipulation or rendering.

Audio

• Audio driver classes provide an abstract audio device layer, which transparently supports ASIO, DirectSound, CoreAudio and ALSA devices.
• Audio device manager class makes it simple to load/save a user's audio device settings between sessions, or to choose an appropriate default device for the system.
• Ready-made UI components for letting the user select their audio and midi device settings.
• A set of audio stream classes allow audio graphs to be constructed and played - types of audio filter include wave file readers, sample-rate converters, mixers, and tone generators.
• A set of audio file format readers and writers include support for WAV, AIFF, Flac and Ogg-Vorbis
• A Synthesiser class allows simple creation of polyphonic synthesisers, which can be easily driven by midi input using the midi classes.
• On Mac and PC, a cross-platform Audio CD reader allows CD audio to be extracted as easily as reading any other audio file.
• The Juce Audio Plugin toolkit allows a single audio plugin class to be compiled for a variety of plugin formats - currently it supports VST (PC, Mac and Linux), AudioUnit (Mac), and RTAS (PC and Mac).

Midi

• Midi input/output support on Mac and PC
• Midi message wrapper classes make it easy to manipulate midi using a high-level programming interface
• Midi buffer classes for efficient collating and editing of midi streams
• Midi keyboard state objects will monitor a midi stream and provide information about the state of a virtual keyboard
• Classes for merging and re-timing midi input streams to synchronise with audio streams.
• Support for reading/writing standard midi format files.

XML

• A very fast, fully-integrated XML parser, supporting entity expansion, and external entities.
• XML structure classes make it easy to use XML objects as general-purpose data structures in your code, with quick methods for interpreting attributes as various numeric types other than strings.
• Because the XML parser is available throughout the library very cheaply, many other classes make use of it to provide quick and easy ways to use XML data - e.g. the URL class has a method to read and parse the contents of an internet URL.

Application Utilities

• Simple cross-platform application startup/shutdown (although Juce can also be used to build plugins and DLLs with a custom entry/exit points).
• Classes for language-localisation of string constants, using a simple translation file format.
• Undo/redo support using an undo manager and undoable action classes
• Base classes for file-based document handling, to handle all the logic involved in loading/saving documents, knowing when they are altered, keeping track of recently opened files, etc.
• Versatile set of classes for managing a set of named application commands, which can be triggered automatically by menus, keystrokes or buttons. A powerful command-target structure gives flexible control over the dispatch of commands, and ready-made UI components allow sets of key-mappings to be edited and stored.
• Property file support makes it very simple to store named values in a settings file for persistance between sessions. All platform-specific details about where this file should be stored are handled automatically.
• A global logging object can be assigned, which is takes any output from Juce's internal logging as well as the application's log. A pre-made logger class is provided to write to a file, but custom ones can be added.

Networking

• Input stream classes to handle downloads via HTTP and FTP.
• URL parsing.
• Cross-platform low-level sockets.
• An inter-process communication abstraction layer allows communication channels to be set up using either sockets or named pipes, to either a local or remote machine.

Cryptography

• Large prime number generator
• RSA Key generator and codec
• BlowFish codec
• MD5 hashcode creation class

Miscellaneous

• Zip file format parser can parse and decompress file streams from zip files.
• Unique 128-bit i.d. generator
• Various platform-specific utilities, e.g. registry read/write functions on Windows; Pascal string and FSSpec converters on the Mac.
• High-accuracy performance counter class allows timing of code sections and averaging over multiple runs.