Features

From JUCE

JUCE is divided up into modules containing different sets of functionality, and your application can use any number of these modules, according to the features you require.

Here's a summary of the main features that each module provides:

Contents 1 juce_core 2 juce_data_structures 3 juce_events 4 juce_graphics 5 juce_gui_basics 6 juce_gui_extra 7 juce_cryptography 8 juce_opengl 9 juce_video 10 juce_audio_basics 11 juce_audio_devices 12 juce_audio_formats 13 juce_audio_plugin_client 14 juce_audio_processors 15 juce_audio_utils 16 The Introjucer 17 The Jucer

juce_core

This module provides a set of fundamental classes that are required by all the other modules.

• Large set of versatile container classes.
• A powerful set of string classes which can manipulate UTF-32, UTF-16 and UTF-8.
• A comprehensive set of file, directory and I/O stream classes, including streams for files, URLs, memory, buffering, built-in zlib-based compression, and zip-file handling.
• 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.
• Classes for language-localisation of string constants, using a simple translation file format.
• Many utility functions and classes for data conversion, time and date, atomic operations, maths functions, random numbers, etc.
• 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.
• 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.
• Cross-platform low-level sockets.
• 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.

juce_data_structures

• Undo/redo support using an undo manager and undoable action classes
• The ValueTree and Value classes provide a very powerful general-purpose data structure which provides change notifications and automatic undo/redo support.
• 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.

juce_events

This module provides access to the operating system's messaging queue.

• Classes for timers, async message dispatch, change notification, asynchronous callbacks.
• Simple cross-platform entry-points for 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).
• 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.

juce_graphics

This module provides classes for a wide range of 2D rendering tasks.

• Powerful 2D rendering engine providing sub-pixel accurate, anti-aliased drawing.
• 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; an OpenGL-based rendering engine is provided in the juce_opengl module)
• Image support for 24-bit RGB and 32-bit ARGB images.
• 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 image data into C++ code using the Introjucer makes it simple to add graphic resources in a platform-independent way.
• A set of geometry classes including lines, rectangles, points, rectangular regions, affine transforms, and more.
• Geometric paths and shapes can be created and manipulated with the Path class.
• Gradient fills can be linear and radial, with custom gradients
• All drawing operations can have arbitrary 2D affine-transforms applied to them

juce_gui_basics

This module provides the bulk of the library's GUI classes.

• 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.
• All components can have arbitrary 2D affine-transforms applied to them.
• 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 ways, 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.
• Drop-shadows are used on JUCE top-level windows (if possible and where the OS doesn't already do this itself).
• A set of classes allow components to be positioned using expressions which describe their layout in terms of other components or markers.
• 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, converting them into JUCE's Drawable objects, ready for further manipulation or rendering.
• Versatile set of classes for managing 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.

juce_gui_extra

• 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.
• Support for embedding OS-specific elements into a JUCE GUI, e.g. of ActiveX, NSView objects.
• A source code editor component with syntax-highlighting support
• Miscellaneous UI classes whose purpose is too specific to warrant their inclusion in the juce_gui_basics module.

juce_cryptography

• Large prime number generator
• RSA Key generator and encrypter
• BlowFish codec
• MD5 and SHA hashcode creation classes

juce_opengl

• Classes for attaching an OpenGL view to any juce component
• A shader-accelerated 2D rendering engine which can be used to replace the standard JUCE rendering engine
• Classes for managing textures, framebuffers, shader program compilation
• Assorted helper classes for GL and 3D tasks.

juce_video

• Support for embedded video playback using QuickTime or DirectShow
• Video camera capture makes it easy to preview and record from webcams

juce_audio_basics

• 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.
• Support for reading/writing standard MIDI format files.
• 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.
• 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.

juce_audio_devices

• Audio device classes provide an abstract audio device layer, which transparently supports ASIO, WASAPI, DirectSound, CoreAudio, iPhone Audio, ALSA, JACK and Android OpenSL devices.
• AudioDeviceManager class makes it simple to load/save a user's audio and MIDI device settings between sessions, and to choose appropriate defaults for the system.
• MIDI input and output support, including support for creating virtual MIDI devices on Mac and Linux.

juce_audio_formats

• A set of audio file format readers and writers include support for WAV, AIFF, Flac, Ogg-Vorbis, and platform-specific decoders such as WMA, CoreAudio.
• 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.

juce_audio_plugin_client

• 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).

juce_audio_processors

• Classes for constructing and playing graphs of interconnected audio/midi processor nodes.
• Support for loading and running VST and AU plugins.

juce_audio_utils

• Ready-made UI components provide UI for selecting audio and MIDI device settings, showing MIDI keyboards, etc.
• Audio waveform thumbnail components.

The Introjucer

The Introjucer is JUCE's project management tool. You can build it from the source-code included in the JUCE source tree, or download a pre-built binary from SourceForge.

• Use it like an IDE to build your project, adding source files to a tree, and editing the platform-specific settings for the various compilers that you want to target.
• Once created, your project can be automatically exported as a bunch of ready-to-run projects for Xcode, Visual Studio, Linux make, or Android Ant.
• A set of wizards make it easy to create application or plugin projects.
• As well as generating projects, the introjucer will also convert any binary resource files in your project to C++ source-code, which is automatically included in the generated projects.
• Also includes a utility for downloading the latest version of JUCE without needing to use the GIT.
• Future plans for the Introjucer will see it become a full IDE, with integrated GUI designer and code editor.

The Jucer

• The Jucer is JUCE's UI component builder application. It comes 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.