Raw Material Software

Summary of JUCE's features:

JUCE contains over 250,000 lines of painstakingly hand-crafted code, and hundreds of classes.. It's hard to summarise all the features, but these are some of the main categories.

There's also a complete set of API documentation, 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 I/O stream classes, including streams for files, URLs, memory, buffering and built-in 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.
• A look-and-feel system allows the look of various UI elements to be changed dynamically, and customised by an application.
• OpenGL support makes it easy to have openGL running inside a Juce component.
• Quicktime support allows Quicktime movies to be embedded and controlled through a platform-independent class. (Not available on Linux, of course).
• Video camera catpure makes it easy to preview and record from webcams.
• 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.
• 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.
• Lots of 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 (if 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.
• The built-in software=based rendering engine can be supplemented by native rendering if it's available (e.g. on the Mac and iPhone, CoreGraphics is used for rendering)
• 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
• 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, WASAPI, DirectSound, CoreAudio, iPhone Audio, ALSA and Jack devices.
• Audio device manager class makes it simple to load/save a user's audio and midi 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 file format readers and writers include support for WAV, AIFF, Flac and Ogg-Vorbis
• 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 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.
• Audio-CD burning is supported for Mac and PC.

Midi

• Midi input and output support, including support for creating virtual midi devices on Mac and Linux.
• Midi message wrapper classes make it easy to manipulate midi without having to set the bytes directly.
• Midi buffer classes provide 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. A customisable on-screen keyboard component is provided.
• Classes for merging and re-timing midi input streams to synchronise with audio streams.
• Support for reading/writing standard midi format files.

Audio Plugins

• The audio plugin wrapper classes let you build a single module that functions as a variety of plugin formats - currently it supports VST (PC, Mac and Linux), AudioUnit (Mac), and RTAS (PC and Mac).
• Audio hosting classes are provided for loading and running AU and VST plugins inside your JUCE app.
• Whether you're writing a plugin or loading a third-party plugin, the same base classes are used, so you can easily embed your plugin code into a stand-alone application, or load other plugins into your own plugin.

Browser Plugins

• The browser plugin wrapper classes let you build a single module that functions as an NPAPI (Firefox, Safari, etc on Mac/PC), and ActiveX (Internet Explorer).
• Javascript classes let your plugin communicate with the javascript running on the webpage that's hosting the plugin.

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 that contains XML.

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, and command-line utilities with a traditional main() function).
• 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.
• 128-bit GUID generator
• Various platform-specific utilities, e.g. registry read/write functions on Windows; NSString converters on the Mac.
• High-accuracy performance counter class allows timing of code sections and averaging over multiple runs.