File List

Here is a list of all documented files with brief descriptions:

abstract-tangible-test.cpp	Verify the common base shared by all interface elements of relevance
abstractmo.cpp
abstractmo.hpp
access-casted-o.hpp	Helper for accessing a value, employing either conversion or downcast, depending on the relation of the source type (type of the original value) and the target type (type we need within the usage context)
access-casted-test.cpp	Unit test AccessCasted_test
access-casted.hpp	Helper for accessing a value, employing either a conversion or downcast, depending on the relation of the source type (type of the original value) and the target type (type we need within the usage context)
actions.hpp	Setup of global actions for the main menu
activity-detector-test.cpp	Unit test ActivityDetector_test
activity-detector.hpp	Diagnostic setup to instrument and observe Activity activations
activity-lang.cpp	Supporting implementation for the scheduler activity language framework
activity-lang.hpp	A language framework to define and interconnect scheduler activity verbs
activity-term.hpp	A term of the activity language describing interconnected scheduler activities
activity.hpp	Descriptor for a piece of operational logic performed by the scheduler
add-clip-test.cpp	Unit test AddClip_test
advice-basics-test.cpp	Unit test AdviceBasics_test
advice-binding-pattern-test.cpp	Unit test AdviceBindingPattern_test
advice-configuration-test.cpp	Unit test AdviceConfiguration_test
advice-index-test.cpp	Unit test AdviceIndex_test
advice-multiplicity-test.cpp	Unit test AdviceMultiplicity_test
advice-situations-test.cpp	Unit test AdviceSituations_test
advice.cpp	Implementation of the AdviceSystem, to support the advice collaboration
advice.hpp	Expecting Advice and giving Advice: a cross-cutting collaboration of loosely coupled participants
allocation-cluster-test.cpp	Unit test AllocationCluster_test
allocation-cluster.cpp	Implementation of memory management helper functions for the render engine model
allocation-cluster.hpp	Memory management for the low-level model (render nodes network)
allocation.cpp
allocation.hpp
allocator-handle.hpp	A front-end/concept to allow access to custom memory management
alsa.c	Example implementation how to access the ALSA sound backend
alsa.h	Interfacing to ALSA sound output
app-config-test.cpp	Unit test Appconfig_test
applicable-builder-target-types.hpp	Declaration of all kinds of MObjects to be treated by some "Builder tool"
appstate.cpp	Implementation of the main application object of Lumiera
appstate.hpp	Registering and managing primary application-global services
argument-erasure.hpp	Implementation helper to bind Steam-Layer commands with arbitrary argument tuples
argument-tuple-accept-test.cpp	Unit test ArgumentTupleAccept_test
argument-tuple-accept.hpp	Mixin-templates providing arbitrary function call operators and argument binding functions
assembler.cpp
assembler.hpp
asset-category-test.cpp	Unit test AssetCategory_test
asset-controller.cpp	Implementation of the asset management UI top level
asset-controller.hpp	User interface for asset management
asset-diagnostics.hpp	Small helper and diagnostic functions related to Asset and AssetManager
asset.cpp	Default implementation of the Asset abstraction
asset.hpp	Steam-Layer Interface: Assets
assetmanager.cpp	Implementation of Asset lookup and organisation functions
assetmanager.hpp	Steam-Layer Interface: Asset Lookup and Organisation
assets-panel.cpp	Implementation of a (dockable) panel to organise the assets of a project
assets-panel.hpp	A (dockable) panel to organise the assets of a project
auto.cpp
auto.hpp
basic-setup.cpp	Implementation of self-configuration and bootstrap functionality
basic-setup.hpp	Bootstrap and self-configuration of the application at startup
basicpipetest.cpp	Unit test BasicPipe_test
bin-widget.cpp	Implementation details of a media bin UI
bin-widget.hpp	Widget to render a media bin display in the Lumiera GUI
binary-search.hpp	Textbook implementation of the classical binary search over continuous domain
common/advice/binding.cpp	Implementation of a binding record to represent a match between two patterns
steam/mobject/session/binding.cpp	Implementation details of the Binding MObject to tie a sequence into a timeline or virtual clip
common/advice/binding.hpp	A pattern to define and identify a specific attachment to the Advice system
steam/mobject/session/binding.hpp	MObject in session to represent the top-level binding of a sequence
block-flow-test.cpp	Unit test BlockFlow_test
block-flow.hpp	Memory management scheme for activities and parameter data passed through the Scheduler within the Lumiera render engine
body-canvas-widget.cpp	Implementation details of timeline custom drawing
body-canvas-widget.hpp	Widget to render the body of timeline display, by custom drawing into a canvas control
buffer-local-tag.hpp	A marker data type used in metadata / buffer management of the render engine
buffer-metadata-key-test.cpp	Unit test BufferMetadataKey_test
buffer-metadata-test.cpp	Unit test BufferMetadata_test
buffer-metadata.hpp	Metadata for managing and accessing buffers
buffer-provider-protocol-test.cpp	Unit test BufferProviderProtocol_test
buffer-provider.cpp	Implementation details related to buffer lifecycle management in the render engine
buffer-provider.hpp	Abstraction to represent buffer management and lifecycle within the render engine
buffhandle-attach.hpp	Extension to allow placing objects right into the buffers, taking ownership
buffhandle.hpp	A front-end to support the buffer management within the render nodes
bufftable.hpp	Helper for organisation of render data buffers Used during the process of _"pulling"_ a render node, which recursively might pull further nodes
build-segment-test.cpp	Unit test BuildSegment_test
builder-qualifier-support-test.cpp	Unit test lib::test::BuilderQualifierSupport_test
builder-qualifier-support.hpp	Mix-in to support builder functions to accept optional qualifier terms
builder-tool-test.cpp	Unit test BuilderTool_test
BuilderDoxygen.py
builderfacade.cpp	Implementation of top-level access to builder functionality
builderfacade.hpp	Steam-Layer Facade: access to the Builder
BuilderGCH.py
buildertool.hpp	Visiting-tool mechanism configured specifically for the Builder
Buildhelper.py
buildinstruct.hpp	Helper classes used by asset::ProcPatt to represent the processing information
bus-mo.cpp	Implementation details for a processing pipe representation in the Session model
bus-mo.hpp	MObject in the Session to represent a processing pipe
bus-term-test.cpp	Unit test BusTerm_test
bus-term.hpp	Attachment point to the UI-Bus
button-bar.cpp	Implementation of a toolbar with buttons for use in dialogs
button-bar.hpp	A toolbar widget for use in dialogs
cairo-util.cpp	Implementation of helper functions to support working with lib Cairo
cairo-util.hpp	Utility functions for working with elements from the Cairo vector drawing library
calc-stream-test.cpp	Unit test CalcStream_test
calc-stream.hpp	A core abstraction within the render engine to represent an ongoing calculation
call-queue-test.cpp	Unit test CallQueue_test
call-queue.hpp	A Queue for function invocations, allowing them to be dispatched on demand
canvas-hook-test.cpp	Unit test CanvasHook_test
canvas-hook.hpp	Specialised (abstracted) presentation context with positioning by coordinates
category.cpp	Implementation parts regarding Asset categorisation
category.hpp	Definition of Asset categorisation
channel-descriptor-obsolete.hpp	Representation of the Media type of a data channel used within the engine
clip-presenter.hpp	Presentation control element to model and manage a clip within the timeline UI
clip-widget.cpp	Implementation details of clip display within the Lumiera UI
clip-widget.hpp	This widget provides the concrete rendering of a clip-like entity
asset/clip.cpp	Clip Asset implementation
mobject/session/clip.cpp	Implementation details regarding a media clip as integrated into the edit / session model
asset/clip.hpp	Definition of Asset representation for a media clip
mobject/session/clip.hpp	MObject in the Session to represent a clip on the timeline
cmd-context-test.cpp	Unit test CmdContext_test
cmd-context.cpp	Implementation details of support for context-bound commands
cmd-context.hpp	Abstraction: support for binding command invocation into an UI context
cmd.hpp	Common ID definitions for Steam-Layer commands
cmdline-wrapper-test.cpp	Unit test CmdlineWrapper_test
cmdline.cpp	Implementation of a wrapper / marker to handle "commandline arguments"
cmdline.hpp	Class to encapsulate the typical C-style commandline definition
codec.hpp	Definition of a Codec Asset
command-argument-test.cpp	Unit test CommandArgument_test
command-basic-test.cpp	Unit test CommandBasic_test
command-binding-test.cpp	Unit test CommandBinding_test
command-clone-builder-test.cpp	Unit test CommandCloneBuilder_test
command-closure.hpp	A closure enabling self-contained execution of commands within the SteamDispatcher
command-def.hpp	Actually defining a command and binding it to execution parameters
command-dispatch.hpp	Interface to abstract the SteamDispatcher's ability to handle command messages
command-equality-test.cpp	Unit test CommandEquality_test
command-impl-clone-builder.hpp	Helper for creating an implementation clone, based on the visitor pattern
command-impl.hpp	Top level of the command implementation
command-instance-manager-test.cpp	Unit test CommandInstanceManager_test
command-instance-manager.hpp	Service to support forming and invocation of command instances for use by the UI
command-invocation.hpp	Some additional helpers and convenience shortcuts to ease command invocation
command-message-binding-test.cpp	Unit test CommandMessageBinding_test
command-mutation-test.cpp	Unit test CommandMutation_test
command-mutation.hpp	Core of a Steam-Layer command: functor containing the operation to be executed
command-op-closure.hpp	Implementation of the concrete (sub)-closure of a command, responsible for invoking the actual command operation with the concrete (binding) arguments
command-queue-test.cpp
command-queue.hpp	Implementation building block of SteamDispatcher to organise commands
command-registry-test.cpp	Unit test CommandRegistry_test
command-registry.hpp	Managing command definitions and the storage of individual command objects
command-setup-test.cpp	Unit test CommandSetup_test
command-setup.cpp	Implementation details of instance management for command invocation by the GUI
command-setup.hpp	Provision for setup of concrete commands for use by the UI
command-signature.hpp	Metaprogramming helpers for deriving the precise function signatures necessary to implement a given command
command-simple-closure.hpp	Proof-of-concept implementation of CmdClosure
command-storage-holder.hpp	A passive container record holding the actual command arguments & UNDO state
command-use1-test.cpp	Unit test CommandUse1_test
command-use2-test.cpp	Unit test CommandUse2_test
command-use3-test.cpp	Unit test CommandUse3_test
command.cpp	Implementation of the command frontend
command.hpp	Steam-Layer command frontend
common-services.cpp	Wire library facilities directly into application core services This translation unit serves to complete the definition of some parts of the Lumiera library
steam/common.hpp	Basic set of definitions and includes commonly used together
steam/mobject/builder/common.hpp
vault/common.hpp	Basic set of definitions and includes commonly used together (Vault)
compoundmedia.hpp	Definition of an Asset to represent a clustering or compound of several media
compoundmediatest.cpp	Unit test CompoundMedia_test
config-facade.h	The lumiera::Config wrapper class addresses two issues
config-flags-test.cpp
config-interface.c	A public interface to a (planned) global configuration system
config-interface.h	External interface to the lumiera configuration system
config-keys.cpp
config-keys.hpp	Definition of access keys for global UI configuration
config-lookup.c	Implementation draft for a configuration system (2008)
config-lookup.h	Lookup of configuration keys in a low-level configuration system
config-resolver.cpp	Implementation of bindings between Steam-Layer objects and rules-based configuration
config-resolver.hpp	Definition of the concrete frontend for rule based configuration within the session
config-rules.cpp	Implementation backend part for a configuration rules / query system
config-rules.hpp	Interface for accessing rule based configuration
config-typed.c	Implementation draft for a configuration system (2008)
config-wordlist.c	Draft for a configuration system (2008)
config.c	Implementation of a draft for application configuration from 2008
config.h	Interface for a lumiera configuration system (draft)
configentry.c	Draft for a configuration system (2008)
configentry.h	Draft for a configuration system (2008)
configfacade.cpp	Draft for a facade to access and retrieve configuration values This was created as part of a first draft towards an application wide configuration system
configflags.hpp	Under some circumstances it is necessary to assemble functionality out of elementary building blocks
configitem.c	Implementation draft for a configuration system (2008)
configitem.h	Draft for a configuration system (2008)
conmanager.cpp
conmanager.hpp
connectivity-obsolete.hpp
constraint.cpp
constraint.hpp	Specialised LocatingPin for use in placements
control-impl.hpp	Implementation building blocks for time modification and propagation
control-policy.hpp	Definition of special cases when imposing a change onto concrete time values
control.hpp	Manipulating and monitoring time entities with life changes
controller.hpp	Common Abstraction of all sub-controller, coordinated by the UI-Bus
core-service.hpp	Dedicated service node within the UI-Bus to handle command invocation and presentation state
create-asset-test.cpp	Unit test CreateAsset_test
csv.hpp	Encoding and decoding of data into CSV format
custom-shared-ptr-test.cpp	Unit test CustomSharedPtr_test
data-csv-test.cpp	Unit test DataCSV_test
data.hpp	Manage a table with data records, stored persistently as CSV
dataset.hpp	Definition of an Asset to represent a set of control data An example would be captured animation data from some kind of external controller
db.hpp	Implementation of the Asset database
defs-manager-impl-test.cpp	Unit test DefsManagerImpl_test
defs-manager-impl.hpp	Implementation of the core defaults-management operations
defs-manager-test.cpp	Unit test DefsManager_test
defs-manager.hpp	Management of defaults and default rules
defs-registry-impl-test.cpp	Unit test DefsRegistryImpl_test
defs-registry.hpp	A piece of implementation code factored out into a separate header (include)
del-stash-test.cpp	Unit test DelStash_test
del-stash.hpp	Collecting and finally triggering deleter functions
deleteassettest.cpp	Unit test DeleteAsset_test
deletecliptest.cpp	Unit test DeleteClip_test
depend-inject.hpp	Per type specific configuration of instances created as service dependencies
depend.hpp	Singleton services and Dependency Injection
dependency-configuration-test.cpp	Unit test DependencyConfiguration_test
dependency-factory-test.cpp	Unit test DependencyFactory_test
dependent-assets-test.cpp	Unit test DependentAssets_test
diagnostic-buffer-provider.cpp	Implementation details of unit test support regarding internals of the render engine
diagnostic-buffer-provider.hpp	A facility for writing unit-tests targeting the BufferProvider interface
diagnostic-context-test.cpp	Unit test DiagnosticContext_test
diagnostic-context.hpp	Facility for collecting diagnostic context information explicitly
diagnostic-output-slot.hpp	An facility for writing unit-tests against the OutputSlot interface
diagnostic-output.hpp	Helpers typically used while writing tests
diagnostics.hpp	Extension to the lib::time::Time wrapper, adding output and further diagnostic aids
dialog.hpp	Global constants and definitions for dialogs
diff-complex-application-test.cpp	Unit test DiffComplexApplication_test
diff-ignore-changes-test.cpp	Unit test DiffIgnoreChanges_test
diff-index-table-test.cpp	Unit test DiffIndexTable_test
diff-language.hpp	Fundamental definitions for a representation of changes
diff-list-application-test.cpp	Unit test DiffListApplication_test
diff-list-generation-test.cpp	Unit test DiffListGeneration_test
diff-mutable.hpp	Abstraction or descriptor interface for a data structure exposing the ability for mutation by receiving diff messages
diff-tree-application-simple-test.cpp	Unit test DiffTreeApplicationSimple_test
diff-tree-application-test.cpp	Unit test DiffTreeApplication_test
diff-tree-mutation-listener-test.cpp	Unit test DiffTreeMutationListener_test
diff.cpp	Diff handling framework support code
digxel-configurations-test.cpp	Unit test DigxelConfigurations_test
digxel-test.cpp	Unit test Digxel_test
digxel.hpp	A self-contained numeric element for building structured numeric displays
dispatch-table.cpp	Implementation details of render job generation
dispatch-table.hpp	Implementation details of render job generation
dispatcher-interface-test.cpp	Unit test DispatcherInterface_test
dispatcher-looper-test.cpp
dispatcher.cpp	Implementation parts of job generation within an ongoing render process
dispatcher.hpp	Service abstraction within the render engine for generating render jobs
display-evaluation.cpp	Implementation details of collaborative and global timeline display allocation
display-evaluation.hpp	A collaboration to establish a globally coherent timeline display layout
display-facade.h	Experimental Interface, allowing the Dummy-Player to access the video display widget in the GUI
display-handles.h	Opaque handles and similar typedefs used to communicate via the lumiera::Display and lumiera::DummyPlayer facade interfaces
display-interface-proxy.cpp	Interface-Proxy for the lumiera::Display facade (experimental/deprecated)
display-manager.cpp	Implementation details regarding timeline layout management and widget coordination
display-manager.hpp	Abstraction: service for the widgets to translate themselves into screen layout
display-service.cpp	Implementation of Displayer Service, exposed as a public interface
display-service.hpp	A public service provided by the GUI, implementing the lumiera::Display facade interface
displayer.cpp	Implementation of a displayer object, intended for creating a video display in the UI
displayer.hpp	The Displayer serves as base of all video display implementations
dock-area.cpp	Implementation of dockable UI panels, implemented with the help of lib GDL (»Gnome Docking Library«, formerly aka »Gnome Design Library«)
dock-area.hpp	Management of dockable panels within each top-level WorkspaceWindow
dot-gen.hpp	Support for generation of Graphviz-DOT code for structure visualisation
drag-relocate-controller.hpp	Concrete implementation of a dragging gesture to relocate an UI entity
duck-detector-extension-test.cpp	Unit test DuckDetectorExtension_test
duck-detector-test.cpp	Unit test DuckDetector_test: duck typing through metaprogramming
duck-detector.hpp	Metaprogramming helpers to check for specific properties of a type in question
dummy-builder-context.hpp	Simulated result of a builder run for test purposes, without actual session and model content
dummy-functions.hpp	Dummy functions to support unit testing of function metaprogramming helpers
dummy-image-generator.cpp	Implementation of a generator for dummy video frames for a mockup
dummy-image-generator.hpp	Generator for test dummy video frames to simulate playback of rendered output
dummy-play-connection-test.cpp	Unit test DummyPlayConnection_test
dummy-play-connection.cpp	Implementation of a service for mock render playback to support testing
dummy-play-connection.hpp	Dummy and test setup of playback and rendering, omitting most of the Lumiera engine
dummy-player-facade.h
dummy-player-interface-proxy.cpp	Interface-Proxy for the lumiera::DummyPlayer facade (experimental/obsolete)
dummy-player-service.cpp	Implementation of a service for mock render output to support testing
dummy-player-service.hpp	A public service provided by the Steam-Layer, implementing a dummy/mockup playback process
dummy-session-connection.cpp	Implementation details to build some scaffolding for UI<–>Session integration
dummy-session-connection.hpp	Dummy and scaffolding to help development of the UI - Session connection
dummy-tick.hpp	A timer service invoking a given callback periodically
asset/effect.cpp	Implementation level functionality regarding the Asset representation of effects
mobject/session/effect.cpp
asset/effect.hpp	Definition of an Asset representation for any kind of effect or media processor
mobject/session/effect.hpp
elem-access-dir.hpp	A service to discover and access raw UI elements in a cross cutting way
element-access-test.cpp	Unit test ElementAccess_test
element-access.hpp	Interface to discover and access raw UI elements in a cross cutting way
element-box-widget.cpp	Implementation details of the UI building block to display an ID label
element-box-widget.hpp	Widget to render an ID label with associated icon
element-query.hpp	Search and query services to discover contents of the session
element-tracker.hpp	Tracking instances automatically on creation and disposal
engine-config.cpp	Implementation of engine configuration and parametrisation
engine-config.hpp	Access point to configuration of engine parameters
engine-ctx-facilities.cpp
engine-ctx-facilities.hpp	Implementation parts of render engine operational services
engine-ctx.hpp	Dependency context to hold global parameters and services for the render engine
engine-diagnostics.hpp	An facility to check and monitor engine operations
engine-interface-test.cpp	Unit test EngineInterface_test
engine-observer.hpp	Render Engine performance data collection service
engine-service-mock.cpp	Implementation translation unit for a mock render engine for unit testing
engine-service-mock.hpp	Placeholder implementation of the render engine for test and diagnostics
engine-service.cpp	Implementation parts related to the engine service abstraction
engine-service.hpp	Access point for the (core) calculation service of the render engine
enginefacade.cpp	Subsystem descriptor and configuration for the render engine
enginefacade.hpp	Global control interface for the render engine subsystem
entry-id-test.cpp	Unit test EntryID_test
entry-id.hpp	Bare symbolic and hash ID used for accounting of asset like entries
error-exception.cpp	Implementation of C++-style error handling
error-log-display.hpp	Widget to display error messages to be accessible in non-modal way
error-log.cpp	Implementation details of incident logging and persistence
error-log.hpp	An entity to collect, possibly filter and persist incident records
error-state.c	Implementation of C-style error handling in Lumiera
error.h	Lumiera error handling (C interface)
error.hpp	Lumiera error handling (C++ interface)
event-log-test.cpp	Unit test EventLog_test
event-log.cpp	Implementation details of event logging and verification for unit tests
event-log.hpp	Support for verifying the occurrence of events from unit tests
example-plugin.c	Dummy C plug-in to cover the plugin loader for unit test This file defines a Lumiera plug-in written in plain C, implementing the lumieraorg_testhello interface
example-plugin.cpp	Dummy C++ plug-in to cover the plugin loader for unit test This file defines a Lumiera plug-in written in C++, implementing the lumieraorg_testhello interface
exception-error-test.cpp	Unit test ExceptionError_test
exit-node.hpp	Effective top-level exit point to pull rendered data from the nodes network
expander-revealer.hpp	Helper components to implement some standard UI-element actions by installing a functor
explicitplacement.hpp	Core abstraction: completely resolved placement of an MObject Within the session model, all media objects are attached with the help of mobject::Placement elements
extent-family-test.cpp	Unit test ExtentFamily_test
extent-family.hpp	Memory management scheme for cyclically used memory extents
facade.cpp	Implementation of subsystem lifecycle behaviour for the core parts of Steam-Layer
stage/ctrl/facade.hpp
steam/facade.hpp
fake-configrules.cpp	Implementation of a fake query resolution service based on preconfigured answers
fake-configrules.hpp	Mock/Test/Debugging Implementation of the config rules system
feed-manifold-obsolete.hpp
feed-manifold-test.cpp	Unit test FeedManifold_test
feed-manifold.hpp
file-support-test.cpp	Unit test FileSupport_test
file.cpp	Storage and implementation details for filesystem helpers
file.hpp	Includes the C++ Filesystem library and provides some convenience helpers
fixedlocation.cpp
fixedlocation.hpp	Specialised LocatingPin for use in Placement, especially for globally fixed positions The FixedLocation is assumed to play a central role within the Build process, which ultimately aims ad resolving any part of the session into either a wiring directive or a piece of media or processing to happen at a location fixed in time
fixture-change-detector-test.cpp	Unit test FixtureChangeDetector_test
fixture-change-detector.hpp	Work out the part of the Fixture changed by a build process
fixture-segment-test.cpp	Unit test FixtureSegment_test
fixture.cpp	Implementation of the Fixture datastructure
fixture.hpp	Backbone data structure of the low-level render node model The fixture defines the boundary between the Session (high-level) realm and the internals of the render engine
flash-deco.hpp	Decorator to add the ability to display a visual flash action to a GTK widget
focus-tracker.cpp	Implementation helper functionality to link the global activity spot to typical UI focus and activation changes
focus-tracker.hpp	Helper to track focus/activation changes to move the activity "Spot" automatically
fork.cpp	Implementation of the basic grouping device within the session ("Track" / "Media Bin")
fork.hpp	Organisational grouping device within the Session model ("Track" / "Media Bin")
format-cout-test.cpp	Unit test FormatCOUT_test
format-cout.hpp	Automatically use custom string conversion in C++ stream output
format-helper-test.cpp	Unit test FormatHelper_test
format-obj.cpp	Some implementation helpers for simple object display
format-obj.hpp	Simple functions to represent objects, for debugging and diagnostics
format-string-test.cpp	Unit test FormatString_test
format-string.cpp	Implementation for printf-style formatting, based on boost::format
format-string.hpp	Front-end for printf-style string template interpolation
format-support-test.cpp	Unit test FormatSupport_test
format-util.hpp	Collection of small helpers and convenience shortcuts for diagnostics & formatting
formats.hpp	Definition of time code formats This header is part of the Lumiera time and timecode handling library and defines the interfaces and types to deal with the common set of time code formats encountered in video editing
frameid.hpp	Marker tuple to identify a specific frame
function-closure-test.cpp	Testing a combination of std::function objects and metaprogramming
function-closure.hpp	Partial function application and building a complete function closure
function-composition-test.cpp	Unit test FunctionComposition_test
function-erasure-test.cpp	Unit test FunctionErasure_test
function-erasure.hpp	Generic holder for functor objects, concealing the concrete function type
function-signature-test.cpp	Unit test FunctionSignature_test
function.hpp	Metaprogramming tools for transforming functor types
gdkdisplayer.cpp	Dysfunctional implementation code, formerly used to create a video display based on GDK
gdkdisplayer.hpp	Display video via GDK
gen-node-location-query.hpp	Implementation of the stage::interact::LocationQuery interface to work on a GenNode tree
gen-node-test.cpp	Unit test GenNode_test
gen-node.cpp	Generic node element (implementation parts)
gen-node.hpp	Generic building block for tree shaped (meta)data structures
generator-combinations-test.cpp	Unit test GeneratorCombinations_test
generator-combinations.hpp	Metaprogramming facilities to generate combination cases
generator-mo.cpp
generator-mo.hpp	A data generator media object
generator-test.cpp
generator.hpp	Helpers for working with lib::meta::Types (i.e
generic-id-function-test.cpp	Unit test GenericIdFunction_test
generic-record-test.cpp	Unit test GenericRecord_test
genfunc.cpp	Implementation of generic functions to build identification schemes
genfunc.hpp	Generic functions to build identification schemes
gesture-state.cpp	Implementation of a holder and manager for interaction state
gesture-state.hpp	Sub-Service of the InteractionDirector: Hold and maintain InteractionState
global-ctx.hpp	Dependency context to hold all the global UI top-level entities
gnuplot-gen-test.cpp	Unit test GnuplotGen_test
gnuplot-gen.cpp	Definition of building blocks and preconfigured styles for Gnuplot scripts
gnuplot-gen.hpp	Preconfigured setup for data visualisation with Gnuplot
grid.hpp	Definition of a time grid abstraction for time and timecode handling
gtk-base.hpp	A set of basic GTK includes for the UI
gtk-lumiera.cpp	Start up the Lumiera GTK GUI when loading it as dynamic module
gui-notification-facade.h	Major public Interface of the Lumiera GUI
guifacade.cpp	Implementation of the GUI loader
guifacade.hpp	Interface for the GUI loader and for accessing the GUI interface from the lower layers of Lumiera
handle.hpp	A generic opaque handle to an implementation entity, including lifecycle management
handling-pattern-basics-test.cpp	Unit test HandlingPatternBasics_test
handling-pattern-standard-impl-test.cpp	Unit test HandlingPatternStandardImpl_test
handling-pattern.cpp	Implementation of pre-defined command handling patterns
handling-pattern.hpp	Pre-defined command execution skeletons
handling-patterns.hpp	A hard wired collection of predefined command handling patterns
hash-combine.hpp
hash-fnv.c	Implementation of FNV ("Fowler-Noll-Vo") hashing functions
hash-fnv.h	Fowler-Noll-Vo Hashes
hash-generator-test.cpp	Unit test HashGenerator_test
hash-indexed-test.cpp	Unit test HashIndexed_test
hash-indexed.hpp	A template for generating hash based ID tags carrying compile-time type info
hash-standard-to-boost-bridge-test.cpp	Unit test HashStandardToBoostBridge_test
hash-standard.hpp	Helper to use a single extension point for specialised hash functions
hash-value.h	Hash value types and utilities
header-pane-widget.hpp	Widget to show an always visible track header area within the timeline UI
hello-bug-test.cpp	Unit test HelloBug_test
hello.c	Example file to demonstrate integration of stand-alone tools into the build process
helloworldtest.cpp	Unit test HelloWorld_test
hetero-data-test.cpp
hetero-data.hpp	Maintain a chained sequence of heterogeneous data blocks without allocation
IconSvgRenderer.py
id-scheme.hpp	Hard wired definitions for the object identification system used within the UI
identity-of-assets-test.cpp	Unit test IdentityOfAssets_test
incidence-count-test.cpp	Unit test IncidenceCount_test
incidence-count.hpp	Record and evaluate concurrent activations
index-iter-test.cpp
index-iter.hpp	Iterator-style access handle to a referred container with subscript index
index-table.hpp	Generic lookup table for a sequence of unique values
index.hpp	Implementation datastructure for use by the Advice system
infobox-panel.cpp	Implementation of a (dockable) panel to display and manipulate parameters
infobox-panel.hpp	A (dockable) panel to display and manage information and parameters
instancehandle.hpp	A handle template for automatically dealing with interface and plugin registration and deregistration
integral.hpp
interaction-director.cpp	Implementation parts of the top-level controller within the UI
interaction-director.hpp	The top-level controller to connect model and user interaction state
interaction-state.cpp	Common base implementation for UI state tracking components
interaction-state.hpp	Abstraction: a component to watch, maintain and guide UI state
interface-descriptor.h	A data record to describe interface, interface instances and plug-in instances
interface.c	Implementation: handling of interfaces (extension points)
interface.h	Lumiera interface macros and structures
interfaceproxy.hpp	Implementation of C++ binding proxies on top of the (plain-C based) interface system
interfaceregistry.c	Interface instances are published and activated by registering them into a global registry, which is defined here
interfaceregistry.h	Global registry for interfaces (extension points)
interpolator.hpp	Core abstraction: automation parameter interpolator Each interpolator implementation has the ability to resolve intermediary values and to provide a parameter value for every arbitrary point in time.
inventory.hpp	Exposing an ID registration cluster as a Meta Asset
ios-savepoint-test.cpp	Unit test IosSavepoint_test
ios-savepoint.hpp	Capture previous settings of an std::ostream and restore them when leaving scope
item-wrapper-test.cpp	Unit test ItemWrapper_test
iter-adapter-ptr-deref.hpp	Extension adapter for Lumiera Forward Iterators to dereference any pointer values automatically
iter-adapter-stl-test.cpp	Unit test IterAdapterSTL_test
iter-adapter-stl.hpp	Preconfigured adapters for some STL container standard usage situations
iter-adapter-test.cpp	Unit test IterAdapter_test
iter-adapter.hpp	Helper template(s) for creating Lumiera Forward Iterators
iter-chain-search-test.cpp	Unit test IterChainSearch_test
iter-chain-search.hpp	Evaluation mechanism to apply a sequence of conditions onto a linear search
iter-core-adapter-test.cpp	Unit test IterCoreAdapter_test
iter-cursor-test.cpp	Unit test IterCursor_test
iter-cursor.hpp	An iterator with the ability to switch direction
iter-explorer-test.cpp	The IterExplorer_test covers and demonstrates a generic mechanism to expand and evaluate tree like structures
iter-explorer.hpp	Building tree expanding and backtracking evaluations within hierarchical scopes
iter-queue-test.cpp	Unit test IterQueue_test
iter-source-test.cpp	Unit test IterSource_test
iter-source.hpp	Extension module to build an opaque data source, accessible as Lumiera Forward Iterator
iter-stack-test.cpp	Unit test IterStack_test
iter-stack.hpp	Conveniently iterable stack and queue containers
iter-zip-test.cpp
iter-zip.hpp	Iterator builder to combine several iterables into a tuple sequence
iterable-classification-test.cpp	Unit test IterableClassification_test
itertools-test.cpp	Unit test IterTools_test
itertools.hpp	Helpers for working with iterators based on the pipeline model
jack-output.cpp
jack-output.hpp
job-hash-test.cpp	Unit test JobHash_test
job-planning-pipeline-test.cpp	Unit test JobPlanningPipeline_test
job-planning-test.cpp	Unit test JobPlanning_test
job-planning.hpp	Aggregation of planning data to generate actual frame calculation jobs
job-ticket.cpp	Implementation details of preparing and performing job invocations
job-ticket.hpp	Execution plan to generate render jobs within a specific render process
job.cpp	Implementation of render job invocation
job.h	Definition of a render job
label.cpp
label.hpp	A marker or reference point in the Session
late-bind-instance-test.cpp	Unit test LateBindInstance_test
lazy-init-test.cpp	Unit test LazyInit_test
lazy-init.hpp	Building block to allow delayed initialisation of infrastructure tied to a functor
libgavl.cpp	Implementation details of using the GAVL library for processing
libgavl.hpp	Concrete implementation of the MediaImplLib facade to work with libGAVL
life-cycle-test.cpp	Unit test LifeCycle_test
lifecycle-advisor.hpp	Implementation facility providing an operation skeleton of session lifecycle
lifecycle.cpp	Implementation of installable callbacks for lifecycle events
lifecycle.h	Installing and invoking of application lifecycle event callbacks
lifecycleregistry.hpp	Helper for registering lifecycle event callbacks, which are provided as a global service by lumiera::AppState
limits.hpp	Hard wired safety limits
linked-elements-test.cpp	Unit test LinkedElements_test
linked-elements.hpp	Intrusive single linked list with optional ownership
list-diff-application.hpp	Apply a "list diff" to a concrete sequence of elements in a container
list-diff-detector.hpp	Compare two data sequences to find or describe differences
list-diff.hpp	A token language to represent changes in a list of elements
llist.h	Intrusive cyclic double linked list There is only one node type which contains a forward and a backward pointer
load-controller.hpp	Scheduler resource usage coordination
locatingpin.cpp	Implementation of the query resolving mechanics within a Placement
locatingpin.hpp	Implementing the Placement mechanics
lockerror.c	Implementation and definitions for error-handling on low-level locking
lockerror.h	Definitions and declarations for error-handling on low-level locking
logging.h	This header is for including and configuring NoBug
looper.hpp	Implementation building block of SteamDispatcher to control waiting and timing
luid.c	Implementation functions for Lumiera's unique object identifier (LUID)
luid.h	Lumiera unique object identifier
luidgen.c	Generate a fixed LUID to be hard-wired into source code
LumieraEnvironment.py
main.c	A stand alone application to test integration with output frameworks
main.cpp	Lumiera application main function
make-clip-test.cpp	Unit test MakeClip_test
marker-widget.cpp	Implementation of marker display
marker-widget.hpp	Widget to show a marker at various places
maybe-compare.hpp	Helpers for fail-safe invocation of comparison operations from generic code
media-access-facade.cpp	Implementation binding to query for a media file's properties
media-access-facade.hpp	Abstraction interface to query for a media file
media-access-mock-test.cpp	Unit test MediaAccessMock_test
media-access-mock.cpp	Mock implementation of the Interface normally used to query media file information from the data backend
media-access-mock.hpp	Unit test helper to access an emulated media file
media-impl-lib.hpp	Abstraction to represent (metadata) of an external library to handle media data Lumiera delegates most actual media data processing to well established external libraries
media-structure-query-test.cpp	Unit test MediaStructureQuery_test
media.cpp	Implementation regarding the Media Asset abstraction
media.hpp	Media data represented a specific kind of Asset
memento-tie-test.cpp	Unit test MementoTie_test
memento-tie.hpp	A special binding used by Steam-Layer commands for capturing UNDO state information
menu-button.cpp	Implementation of the MenuButton widget, to display a menu when clicked
menu-button.hpp	A button widget that displays a menu when clicked
meta-cmd.cpp	Actual definition of Steam-Layer command scripts for meta/ctrl actions
meta-utils-test.cpp	Unit test MetaUtils_test
asset/meta.cpp	Implementation details regarding the Meta Asset category
mobject/session/meta.cpp	Implementation details regarding the Meta asset abstraction
asset/meta.hpp	Internal and organisational metadata
mobject/session/meta.hpp	Intermediate Asset interface: metadata and processing instructions
microbenchmark-adaptor.hpp	Helpers and wrappers so simplify usage of micobenchmark.hpp
microbenchmark.hpp	Functions to perform (multithreaded) timing measurement on a given functor
mini-button.hpp	Adapter to wrap button widgets intended to serve as tool buttons
mixer-widget.cpp	Implementation details of a mixing desk control
mixer-widget.hpp	Widget to render a channel mixer within the Lumiera GUI
mobject-interface-test.cpp	Unit test MObjectInterface_test
mobject-ref-test.cpp	Unit test MObjectRef_test
mobject-ref.cpp	Implementation part of the MObjectRef facility
mobject-ref.hpp	External MObject/Placement reference
mobject.cpp	Top level implementation functions globally relevant to the session model
mobject.hpp	Core abstraction of the Session model: a media object
mobjectfactory.cpp
mobjectfactory.hpp	Core factory to generate media objects for use in the Session model
mock-dispatcher.cpp	Implementation of a dummy render job for unit tests
mock-dispatcher.hpp	Mock data structures to support implementation testing of render job planning and frame dispatch
mock-elm.hpp	A generic interface element instrumented for unit testing
mock-support-test.cpp	Unit test MockSupport_test
model-port-registry-test.cpp	Unit test ModelPortRegistry_test
model-port-registry.cpp	Implementation details of model port descriptors and references
model-port-registry.hpp	Mutation and management facility for model ports within the builder
model-port.hpp	Organising the output data calculation possibilities
mould.hpp	Builder tool kit
multifact-argument-test.cpp	Unit test MultiFactArgument_test
multifact-singleton-test.cpp	Unit test MultiFactSingleton_test
multifact-test.cpp	Unit test MultiFact_test
multifact.hpp	Framework for building a configurable factory, to generate families of related objects
mutation-message-test.cpp	Unit test MutationMessage_test
mutation-message.hpp	Generic Message with an embedded diff, to describe changes to model elements
mutation.cpp	A collection of concrete forms of time mutation
mutation.hpp	Modifying time and timecode values
mutex.c	Mutual exclusion locking
mutex.h	Mutual exclusion locking, header
name-chooser.cpp	Implementation details of NameChooser, a dialog to enter a name string
name-chooser.hpp	Dialog to enter a string name
navigator-widget.cpp	Implementation detail of the navigation control elements presented at top of the timeline UI's header pane
navigator-widget.hpp	Widget for navigation controls within the timeline UI
navigator.cpp	Implementation of global interface navigation mechanisms
navigator.hpp	Global interface navigation control
netnodefacade.cpp	Subsystem descriptor and configuration for a renderfarm node
netnodefacade.hpp	Global control interface for running Lumiera as a renderfarm node
nexus.hpp	Core hub and routing table of the UI-Bus
no-instance.hpp	Metaprogramming helper to prevent an entity to be ever instantiated at runtime
nobug-init.cpp	Implementation function for automatic trigger of NoBug initialisation
nobug-init.hpp	Trigger the basic NoBug initialisation by placing a static variable
nobug-resource-handle-context.hpp	Thread-local stack of NoBug resource handles
nocopy.hpp	Mix-Ins to allow or prohibit various degrees of copying and cloning
node-base-test.cpp	Unit test NodeBase_test covers elementary components of render nodes
node-builder-test.cpp	Unit test NodeBuilder_test demonstrates how to build render nodes
node-builder.hpp	Specialised shorthand notation for building the Render Node network
node-devel-test.cpp	Unit test NodeDevel_test verifies helpers for testing of render nodes
node-factory.cpp	Implementation of render node setup and wiring
node-factory.hpp	A factory to build processing nodes
node-feed-test.cpp	Feeding into and retrieving data from render nodes is covered by NodeFeed_test
node-graph-attachment-test.cpp	Unit test NodeGraphAttachment_test
node-graph-attachment.hpp	Link from the Fixture datastructure into the render node network
node-link-test.cpp	The NodeLink_test covers the essence of connected render nodes
node-meta-test.cpp	Naming and hash-key identification of render nodes is covered by NodeMeta_test
node-opera-test.cpp	Let the nodes sing with NodeOpera_test
node-storage-test.cpp	Actual storage setup for render nodes is demonstrated by NodeStorage_test
nodecreatortool.cpp	Implementation of visitor logic to actually build the render node network
nodecreatortool.hpp	Visitor tool to work on the concrete model objects when building the render node network
nodeinvocation-obsolete.hpp	Organise the state related to the invocation of s single ProcNode::pull() call This header defines part of the "glue" which holds together the render node network and enables to pull result frames from the nodes
nodeoperation-obsolete.hpp	Chunks of operation for invoking the rendernodes
nodewiring-config.hpp	Sometimes we need to choose a different implementation for dealing with some special cases
nodewiring-obsolete.cpp	Implementation of node wiring to build a render node network
nodewiring-obsolete.hpp
nop-job-functor.hpp	Generic implementation of a JobFunctor to perform no calculations
notification-hub.hpp	Controller to receive and handle notification messages for the user
notification-interface-proxy.cpp	Interface-Proxy for the stage::GuiNotification facade
notification-service.cpp	Implementation of notifications and updates within the GUI
notification-service.hpp	A public service provided by the GUI, implementing the stage::GuiNotification facade interface
null-value-test.cpp	Unit test NullValue_test
null-value.hpp	Singleton-style holder for NIL or default values
opaque-holder-test.cpp	Unit test OpaqueHolder_test
opaque-holder.hpp	Helper allowing type erasure while holding the actual object inline
opaque-unchecked-buffer-test.cpp	Unit test OpaqueUncheckedBuffer_test
operationpoint.cpp	Implementation of primitive builder operations on at the current point of operation
operationpoint.hpp	Abstraction to represent the current point of operation within the builder
option.cpp	Implementation of commandline argument handling, based on lib Boost »program options«
option.hpp	Front-end for handling the commandline arguments
optional-ref-test.cpp	Unit test OptionalRef_test
optional-ref.hpp	Checked, switchable reference
Options.py
ordering-of-assets-test.cpp	Unit test OrderingOfAssets_test
output-designation.cpp	Implementation details of OutputDesignation and OutputMapping
output-designation.hpp	Core abstraction: symbolic representation of some output target
output-director.cpp	Implementation of global output connection management
output-director.hpp	A global service to coordinate and handle all external output activities
output-manager.hpp	A global service to handle all external output connections
output-mapping-test.cpp	Unit test OutputMapping_test
output-mapping.hpp	Translating and wiring output designations
output-slot-connection.hpp	Interface for concrete output implementations to talk to the OutputSlot frontend
output-slot-protocol-test.cpp	Unit test OutputSlotProtocol_test
output-slot.cpp	Generic implementation functionality common to all output connections
output-slot.hpp	An (abstract) capability to send media data to an external output
p.hpp	Customised refcounting smart pointer
panel-bar.cpp	Implementation of a custom container widget to place toolbar buttons into the active docking header area of GDL docking panels
panel-bar.hpp	Custom container widget to allow placing toolbar buttons into the active docking header area of GDL docking panels
panel-locator.hpp	Access and query front-end to locate, access and place docking panels
panel-manager.cpp	Implementation of dockable UI panels, implemented with the help of lib GDL (»Gnome Docking Library«, formerly aka »Gnome Design Library«)
panel-manager.hpp	Management of dockable panels
panel.cpp	Implementation base for all dockable panels
panel.hpp	Base class and interface for all dockable panels
parameter.cpp	Implementation functions of the Parameter abstraction
parameter.hpp	Core abstraction: parameter to be controlled and possibly automated
paramprovider.cpp	Implementation functions of the Parameter abstraction
paramprovider.hpp	Core abstraction: an entity to expose a single parameter
patchbay-widget.cpp	Implementation details of the patchbay, allowing to tweak parameters of a fork's placement
patchbay-widget.hpp	Widget to hold the track head controls within the timeline header pane UI
path-array-test.cpp	Unit test PathArray_test
path-array.hpp	Foundation abstraction to implement path-like component sequences
pathmanager.cpp	Implementation functionality regarding decision about the proper wiring and calculation strategy for rendering
pathmanager.hpp	Facility to decide upon the actual render strategy
pipe-widget.cpp	Implementation details of a pipe configuration UI
pipe-widget.hpp	A component to show and manipulate the processing pipe configuration
pipe.cpp	Implementation details regarding the Asset representation of a processing Pipe
pipe.hpp	A "processing pipe" represented as Asset
placeholder-command.hpp	Generate fake commands with stub operations and the ability to verify invocation
placement-basic-test.cpp	Unit test PlacementBasic_test
placement-hierarchy-test.cpp	Unit test PlacementHierarchy_test
placement-index-query-resolver.cpp
placement-index-query-resolver.hpp	Implementing resolution of "discover contents"-queries based on PlacementIndex
placement-index-query-test.cpp	Unit test PlacementIndexQuery_test
placement-index-test.cpp	Unit test PlacementIndex_test
placement-index.cpp	Implementation of core session storage structure
placement-index.hpp	Core of the session implementation datastructure
placement-object-identity-test.cpp	Unit test PlacementObjectIdentity_test
placement-ref-test.cpp	Unit test PlacementRef_test
placement-ref.hpp	A generic reference mechanism for Placements, as added to the current session
placement-scope-test.cpp	Unit test PlacementScope_test
placement.cpp	Implementation functions belonging to the Placement entity
placement.hpp	Core abstraction: placement of a media object into session context
Platform.py
play-controller.cpp	Implementation of the control- / management frontend(s) exposed to clients for talking to an ongoing PlayProcess
play-controller.hpp	Functionality for driving and controlling an ongoing playback or render
play-facade.hpp	Public access point to the playback service provided by the »play-out subsystem«
play-process.cpp	Implementation to organise an ongoing playback/rendering process
play-process.hpp	Organisational unit of an ongoing render- or playback process
play-service.cpp	Implementation of core parts of the Player subsystem
play-service.hpp	Primary service of the Player subsystem: Starting and controlling render/playback
playback-controller.cpp	Implementation parts of PlaybackController
playback-controller.hpp	This file contains the definition of the playback controller object
player-widget.cpp	Implementation details of the playback control widget
player-widget.hpp	Widget to render the typical playback control element in the UI
plug.cpp
plug.hpp
plugin-dynlib.c	Implementation of plugin loader for dynamic libraries
plugin.c	Plugin loader implementation
plugin.h	Lumiera plugins define 'interfaces' as shown in interface.h, the plugin system handles the loading of all kinds of plugins under the hood, invoked from the interface system
polymorphic-value-test.cpp	Unit test PolymorphicValue_test
polymorphic-value.hpp	A mechanism to allow for opaque polymorphic value objects
ppmpl.h	Preprocessor metaprogramming library
preferences-dialog.hpp	Dialog to manage application preferences
preview.cpp	Implementation details regarding a placeholder / "Proxy" / preview media asset
preview.hpp	Placeholder "proxy" Asset
proc-id.hpp	Metadata interface to generate symbolic and hash ID tags for media processing steps
proc-node.cpp	Translation unit to hold the actual implementation of node processing operations
proc-node.hpp	Interface to the processing nodes and the render nodes network
proc.cpp	Implementation details regarding the Asset representation of a media processing facility
proc.hpp	Data processing Plugins and Codecs can be treated as a specific Kind of Asset
procpatt.cpp	Implementation details related to "processing pattern" assets
procpatt.hpp	Definition of a structural asset to express patterns of wiring or processing Processing patterns can be seen as some kind of "micro code" (or macro code, if you prefer this view angle), which will be executed within the machinery to wire and configure the render nodes network, based on the objects in the Session model
psplay.c	Probabilistic splay tree implementation
psplay.h	Probabilistic splay tree
quantiser-basics-test.cpp	Unit test QuantiserBasics_test
quantiser.cpp	Implementation of support functions to create grid-aligned time and timecode values
quantiser.hpp	Library functions to support the formation of grid-aligned time values
query-diagnostics.hpp	Diagnostic helpers to support test related to predicate queries
query-focus-stack-test.cpp	Unit test QueryFocusStack_test
query-focus-stack.hpp	Implementation facility to work with and navigate nested scopes
query-focus-test.cpp	Unit test QueryFocus_test
query-focus.cpp
query-focus.hpp	Representation of the current scope when navigating the session model
query-resolver-test.cpp	Unit test QueryResolver_test
query-resolver.cpp	Implementation of a framework to query and discover elements based on logical rules
query-resolver.hpp	Framework and to resolve logical queries
query-text-test.cpp	Unit test QueryText_test
query-text.cpp	Implementation bits regarding a syntactical standard representation of predicate queries
query-text.hpp	A generic syntactical representation for all kinds of queries
query-util.cpp	Implementation of helpers for working with predicate queries
query-util.hpp	Utilities to support working with predicate queries
query-utils-test.cpp	Unit test QueryUtils_test
query.hpp	Basic and generic representation of an internal query
random-concurrent-test.cpp	Unit test RandomConcurrent_test
random-draw-test.cpp	Unit test RandomDraw_test
random-draw.hpp	Build a component to select limited values randomly
random-test.cpp	Unit test Random_test
random.cpp	Implementation details and common storage for random number generation
random.hpp	Generating (pseudo) random numbers with controlled seed
rational-test.cpp	Unit test Rational_test
rational.hpp	Rational number support, based on boost::rational
real-clock.cpp	Implementation of simplified access to current system time
real-clock.hpp	Front-end for simplified access to the current wall clock time
rebuildfixturetest.cpp	Unit test RebuildFixture_test
recmutex.c	Recursive Mutexes
recmutex.h	Mutual exclusion locking, header
record.hpp	Special collection to represent object-like data
rectangle.cpp	Implementation of functions to work with rectangular screen ranges
rectangle.hpp	Helper functions to work with rectangular screen ranges
ref-array-impl.hpp	Some (library-) implementations of the RefArray interface
ref-array-test.cpp	Unit test RefArray_test
ref-array.hpp	Abstraction interface: array-like access by subscript
regex.hpp	Convenience wrappers and helpers for dealing with regular expressions
relativelocation.cpp	LocatingPin (constraint) to attach media objects relative to each other
relativelocation.hpp
removefromsettest.cpp	Unit test RemoveFromSet_test
render-configurator.cpp	Implementation functionality to bridge between engine::PlayService and engine::EngineService
render-configurator.hpp	Strategy to hold all the detail knowledge necessary to establish a running render CalculationStream
render-drive.cpp	Implementation elements of render process planning
render-drive.hpp	The active core within a CalcStream, causing the render mechanism to re-trigger repeatedly
render-invocation.cpp	Implementation details regarding the invocation of a single render node
render-invocation.hpp	Initiate a single calculation unit within the renderengine
render-segment-test.cpp	Unit test RenderSegment_test
render.cpp	Implementation of stage:dialog::Render, which is a Dialog to set up a renter process and define output name and format
render.hpp	Dialog to set up a renter process and define output name and format
renderengine.cpp
renderengine.hpp	(Planned) access point to the render engine as service
rendergraph.cpp
rendergraph.hpp
replaceable-item-test.cpp
replaceable-item.hpp	Adapter wrapper to treat non-assignable values as if they were assignable
result-test.cpp	Unit test Result_test
result.hpp	Intermediary value object to represent »either« an operation result or a failure
root.cpp
root.hpp	MObject within the session to represent "the session itself"
rsvg-convert.c	Invoke the rSVG library to render SVG vector graphics with the help of Cairo
ruler-track.cpp	Implementation details regarding custom drawing of track overview and time code ticks and markers onto the TimelineCanvas
ruler-track.hpp	Timeline presentation helper to organise drawing of the overview rulers
ruler-widget.cpp	Implementation details of the time ruler present at top of the timeline display
ruler-widget.hpp	The time overview ruler presented at top of the timeline UI
run.hpp	Simplistic test class runner
safeclib.c	Implementation of error-safe wrappers for some notorious C-Lib functions
safeclib.h	Portable and safe wrappers around some C-Lib functions
say-hello.h	A mock interface to support testing of the interface system
scheduler-activity-test.cpp	Unit test SchedulerActivity_test
scheduler-commutator-test.cpp	Unit test SchedulerCommutator_test
scheduler-commutator.hpp	Layer-2 of the Scheduler: coordination and interaction of activities
scheduler-diagnostics.hpp	An facility to check and monitor the internal workings of the scheduler
scheduler-frontend.cpp	Scheduler service implementation
scheduler-frontend.hpp	Scheduler service access point for higher layers
scheduler-interface-test.cpp	Unit test SchedulerInterface_test
scheduler-invocation-test.cpp	Unit test SchedulerInvocation_test
scheduler-invocation.hpp	Layer-1 of the Scheduler: queueing and prioritisation of activities
scheduler-load-control-test.cpp	Unit test SchedulerLoadControl_test
scheduler-service-test.cpp
scheduler-stress-test.cpp
scheduler-usage-test.cpp	Unit test SchedulerService_test
scheduler.hpp	Service for coordination and dispatch of render activities
scope-cmd.cpp	Actual definition of Steam-Layer command scripts for actions within scope
scope-locator.hpp	Service to build the notion of a current location within the Sesison model
scope-path-test.cpp	Unit test ScopePath_test
scope-path.cpp
scope-path.hpp	An Object representing a sequence of nested scopes within the Session
scope-query-test.cpp	Unit test ScopeQuery_test
scope-query.hpp	Specific queries to explore contents of a scope within the high-level model
scope.cpp	Implementation of placement scopes and scope locator
scope.hpp
scoped-collection-test.cpp	Unit test ScopedCollection_test
scoped-collection.hpp	Managing a collection of non-copyable polymorphic objects in compact storage
scoped-holder-test.cpp	Unit test ScopedHolder_test
scoped-holder-transfer-test.cpp	Unit test ScopedHolderTransfer_test
scoped-holder-transfer.hpp	A mechanism to take ownership without allowing copy
scoped-holder.hpp	Some wrappers for coping with ownership problems
scoped-ptrvect-test.cpp	Unit test ScopedPtrVect_test
scoped-ptrvect.hpp	Managing lifecycle for a collection of objects
scriptrunnerfacade.cpp	Subsystem descriptor and configuration for a controlling and operating Lumiera through bindings to a script language
scriptrunnerfacade.hpp	Global control interface for script driven operation of Lumiera
search-path-splitter-test.cpp	Unit test SearchPathSplitter_test
searchpath.cpp	Implementation of helpers to handle directory search paths
searchpath.hpp	Helpers to handle directory search paths
sectionlock.h	Mutex state handle for locked code sections
segment.cpp
segment.hpp	Building block of the backbone of the low-level (render node) model
segmentation-integration-test.cpp	Integration test SegmentationIntegration_test
segmentation-tool.cpp	Implementation of builder primitives to create a timeline segmentation
segmentation-tool.hpp	Visiting tool to create a viable segmentation of the timeline for rendering
segmentation.cpp	Implementation details regarding the Segmentation of the Fixture
segmentation.hpp	Part of the Fixture datastructure to manage time segments of constant structure
sequence-cmd.cpp	Actual definition of Steam-Layer command scripts for actions within a sequence
sequence.cpp	Implementation parts of the Sequence entity within the Session model
sequence.hpp	Structural building block of the session: a sequence of clips
sess-manager-impl.cpp	Implementation of the Session management functions
sess-manager-impl.hpp	Implementation facility for session management
session-cmd.cpp	Actual definition of Steam-Layer command scripts for session-global actions
session-command-facade.h	Major public Interface to the Session subsystem of Lumiera GUI
session-command-function-test.cpp	Function(integration) test of command dispatch into session thread
session-command-interface-proxy.cpp	Interface-Proxy for the steam::control::SessionCommand facade
session-command-service.cpp	Implementation of command invocation on the Session interface
session-command-service.hpp	A public service offered by the Session, implementing the SessionCommand facade interface
session-element-query-test.cpp	Unit test SessionElementQuery_test
session-element-tracker-test.cpp	Unit test SessionElementTracker_test
session-impl.cpp	Implementation of the global session datastructure
session-impl.hpp	Session and SessionServices Implementation classes
session-interface-modules.hpp	Self-contained sub-elements on the Session API
session-manager-test.cpp	Unit test SessionManager_test
session-modify-parts-test.cpp	Unit test SessionModifyParts_test
session-query.hpp	Supporting queries for session contents
session-service-access-test.cpp	Unit test SessionServiceAccess_test
session-service-defaults.hpp	Implementation level session API: to manage default configured objects
session-service-explore-scope.hpp	Implementation level session API: query a scope
session-service-fetch.hpp	Implementation level session API: resolve a Placement by hash-ID
session-service-mock-index.hpp	Implementation level session API: PlacementIndex mock for tests
session-service-mutate.hpp	Implementation level session API: add or remove Session contents
session-services.cpp	Implementation of some top-level internal services of the session
session-services.hpp	A mechanism for exposing and accessing implementation level services of the session
session-structure-test.cpp	Unit test SessionStructure_test
session.cpp	Actual connection between the Session interface and its Implementation
session.hpp	Primary Interface to the current Session
Setup.py
several-builder-test.cpp	Unit test SeveralBuilder_test
several-builder.hpp	Builder to create and populate instances of the lib::Several container
several.hpp	Abstraction interface: array-like random access by subscript
simple-allocator-test.cpp	Unit test SimpleAllocator_test
simple-allocator.hpp	Frontend and marker interface for allocating small objects explicitly
singleton-subclass-test.cpp	Unit test SingletonSubclass_test
singleton-test.cpp	Unit test Singleton_test
singleton-testmock-test.cpp	Unit test SingletonTestMock_test
size-trait.hpp	Metaprogramming definitions to deal with dependency on implementation size and layout
special-job-fun-test.cpp	Unit test SpecialJobFun_test
special-job-fun.hpp	A configurable one-time job to invoke some special function
specific-contents-query.hpp	Implementation facility to query and retrieve session context with filtering conditions
split-splice-test.cpp	Unit test SplitSplice_test to verify proper working of the »SplitSplice« algorithm
split-splice.hpp
spot-locator.cpp	Implementation details of a machinery to move the global activity "spot"
spot-locator.hpp	Navigating a centre of user activity globally
state-closure-obsolete.hpp
state-manager.hpp	Interface: a component to maintain persistent interface state
state-map-grouping-storage-test.cpp	Unit test StateMapGroupingStorage_test
state-map-grouping-storage.hpp	Implementation of storage for captured presentation state
state-recorder.hpp	Implementation of the PresentationStateManager interface through associative (key-value) store
statistic-test.cpp	Unit test Statistic_test
statistic.hpp
stave-bracket-widget.cpp	Implementation of drawing code to indicate the structure of nested tracks
stave-bracket-widget.hpp	Widget to group tracks visually in the Timeline presentation
steam-dispatcher.cpp	Implementation details of running commands and the builder
steam-dispatcher.hpp	Dispatch and execute mutation operations on the High-level model
stream-type-basics-test.cpp	Unit test StreamTypeBasics_test
stream-type-lifecycle-test.cpp	Unit test StreamTypeLifecycle_test
streamtype.cpp	Implementation of a stream type framework
streamtype.hpp	Framework for classification of media streams
stress-test-rig.hpp	A test bench to conduct performance measurement series
struct-factory-impl.hpp	Private implementation details of creating various structural assets
struct-scheme.hpp	Naming and labelling scheme for structural assets
struct.cpp	Implementation functions to support the "structural asset" abstraction
struct.hpp	Asset representation of structural elements within the model
style-scheme.cpp
style-scheme.hpp	Definition of access keys for uniform UI styling
stypemanager.cpp	Implementation functions of the stream type system
stypemanager.hpp	Interface to the stream type system
styperegistry.hpp	This is part of the implementation of the stream type manager (include)
sub-id-test.cpp	Unit test SubID_test
sub-id.hpp	Extensible symbolic ID type
subsys.cpp	Implementation details of a »subsystem descriptor«
subsys.hpp	Describing dependencies and lifecycle of the application's primary parts
subsystem-runner-test.cpp	The SubsystemRunner_test performs various scenarios regarding start, stop and failure of Subsystems. Its primary purpose is to cover the SubsystemRunner
subsystem-runner.hpp	Manage execution of the independent Subsystems of the Lumiera application
suite.cpp	Implementation of a simple test runner / test suite framework for unit testing
suite.hpp	Building and running a suite of tests, implemented as test classes
switchboard-widget.cpp	Implementation details of the switchboard to control source and overlays of the video viewer
switchboard-widget.hpp	Widget to render a switchboard for controlling the video display sources and overlays
symbol-hashtable-test.cpp	Unit test SymbolHashtable_test
symbol-impl.cpp	Collection of helpers for working with the lib::Symbol
symbol-table.hpp	Registry table for automatically interned strings
symbol-test.cpp	Unit test Symbol_test
symbol.hpp	Marker types to indicate a literal string and a Symbol
sync-barrier-performance-test.cpp	Assess the performance characteristics of lib::SyncBarrier Helpers and setup for the SyncBarrierPerformance_test
sync-barrier-test.cpp	Unit test SyncBarrier_test
sync-barrier.hpp	A N-fold synchronisation latch using yield-wait until fulfilment
sync-classlock-test.cpp	Unit test SyncClasslock_test
sync-classlock.hpp	A special implementation of lib::Sync, where the storage of the object monitor is associated directly to a type rather then to a single object instance
sync-locking-test.cpp	Unit test SyncLocking_test
sync-timedwait-test.cpp	Unit test SyncTimedwait_test
sync-waiting-test.cpp	Unit test SyncWaiting_test
sync.hpp	Object Monitor based synchronisation
tangible.cpp	Common base implementation of all tangible and connected interface elements
tangible.hpp	Abstraction: a tangible element of the User Interface
temp-dir-test.cpp	Unit test TempDir_test
temp-dir.hpp	Manage a temporary directory for storage, with automated clean-up
test-chain-load-test.cpp	Unit test TestChainLoad_test
test-chain-load.hpp	Generate synthetic computation load for Scheduler performance tests
test-coll.hpp	Some bits of unit test helper code to fabricate collections with test data
test-configloader.c	C unit test to cover a config system draft implementation
test-control.hpp	Non-modal dialog window to trigger diagnostics and self test routines
test-dummy-commands.cpp	Implementation of dummy command operations for unit tests
test-dummy-commands.hpp	Some dummy command functions used for building unit test cases
test-dummy-mobject.hpp	A hierarchy of simple dummy-Media-Objects for easy unit testing
test-element-access.hpp	Unit test helper for access to UI elements without actually running an UI
test-errorstate.c	C unit test to cover basic error handling in C code We manage an errorstate variable in thread local storage, which allows to set an global error state per thread
test-helper-test.cpp	Unit test TestHelper_test
test-helper-variadic-test.cpp	Unit test TestHelperVariadic_test
test-helper.cpp	Definition of some widely used test helper functions
test-helper.hpp	A collection of frequently used helper functions to support unit testing
test-interfaces.c	C unit test to cover the basics of our interface and plugin-loading system
test-llist.c	C unit test to cover a linked list library implementation
test-locking.c	C unit test to cover convenience setup for POSIX locking primitives These convenience macros are intended for use in low-level C code, where minimal and precise locking is relevant for performance reasons
test-luid.c	C unit test to cover generation of Lumiera Uniform Identifier hashes
test-mutation-target.hpp	Diagnostic helper for unit tests regarding mutation of custom data
test-nexus.cpp	Implementation of a fake UI backbone for testing
test-nexus.hpp	A fake UI backbone for investigations and unit testing
test-option-test.cpp	Unit test TestOption_test
test-psplay.c	C unit test to cover a probabilistic splay tree library implementation
test-rand-ontology.cpp	Implementation of fake data processing to verify invocation logic
test-rand-ontology.hpp	A faked »media calculation« environment to validate the render node network
test-safeclib.c	C unit test to cover size checked C operations
test-scope-invalid.hpp	Unit test helper to generate deliberately wrong placement scopes
test-scopes.cpp	Implementation of nested test scopes to cover the placement index
test-scopes.hpp	Unit test helper to generate a system of nested test scopes
test-target-obj.hpp	Dummy target object to be created by factory for unit tests Used to verify sane memory management and instance lifecycle for such objects generated as singleton or by factory
test-time.c	C unit test to cover the basic low-level time handling operations
test-tracking-test.cpp	Unit test TestTracking_test
test.h	Helpers and support macros for defining test executables in C
testasset.cpp	Implementation of a mocked Asset for unit tests
testasset.hpp	A mock asset to support unit testing
testclip.cpp	Implementation of a stubbed clip object to support unit testing
testclip.hpp	A stub implementation of the Clip interface for unit testing
testclipasset.hpp	A placeholder Clip asset to support unit testing
testframe-test.cpp	Unit test TestFrame_test
testframe.cpp	Implementation of fake data frames to support unit testing
testframe.hpp	Unit test helper to generate fake test data frames
testoption.cpp	Implementation of commandline parsing for the unittest test-suite
testoption.hpp	Commandline options for our unittest test-suite executable
testroot.hpp	Setup of a faked session root for unit testing
testrunner.cpp	Lumiera unit test suite A simple test runner application
testsession1.hpp	Dummy session content prepared for unit test
teststreamtypes.hpp	Unit test helper to create fake streamtype information
text-template-gen-node-binding.hpp	A complement to allow instantiation of a TextTemplate with ETD data
text-template-test.cpp	Unit test TextTemplate_test
text-template.hpp	A minimalistic text templating engine with flexible data binding
thread-wrapper-autonomous-test.cpp	Unit test ThreadWrapperAutonomous_test
thread-wrapper-join-test.cpp	Unit test ThreadWrapperJoin_test
thread-wrapper-lifecycle-test.cpp	Unit test ThreadWrapperLifecycle_test
thread-wrapper-self-recognition-test.cpp	Unit test ThreadWrapperSelfRecognitionTest_test
thread-wrapper-test.cpp	Unit test ThreadWrapper_test
thread.cpp
thread.hpp	Convenience front-end to simplify and codify basic thread handling
tick-service.hpp	A timer service invoking a given callback periodically
time-basics-test.cpp	Unit test TimeBasics_test
time-control-test.cpp	Unit test TimeControl_test
time-formats-test.cpp	Unit test TimeFormats_test
time-grid-basics-test.cpp	Unit test TimeGridBasics_test
time-grid.cpp	Implementation of access to time-quantised reference scales
time-grid.hpp	To establish a reference scale for quantised time values
time-mutation-test.cpp	Unit test TimeMutation_test
time-parsing-test.cpp	Unit test TimeParsing_test
time-quantisation-test.cpp	Unit test TimeQuantisation_test
time-value-test.cpp	Unit test TimeValue_test
time.cpp	Lumiera time handling core implementation unit
time.h	Common functions for handling of time values
timecode-widget.cpp	Widget for timecode display and input
timecode-widget.hpp	Widget for timecode display and input
timecode.cpp	Implementation parts of the timecode handling library
timecode.hpp	Timecode handling library This header defines the foundation interface TCode to represent a grid aligned time specification, given in some well-established time code format
timeline-controller.cpp	Implementation details of timeline operation management and control
timeline-controller.hpp	Controller to supervise operation of timeline display in the UI
timeline-gui.cpp	Implementation details a delegating anchor proxy for a TimelineWidget
timeline-gui.hpp	Anchor point and placeholder for the UI representation of a Timeline from the session
timeline-layout.cpp	Implementation details of global timeline layout management
timeline-layout.hpp	A core service of the timeline UI to ensure consistent display and layout of all components within the timeline
timeline-panel.cpp	Implementation of the dockable panel to hold the main timeline display
timeline-panel.hpp	A dockable container to hold a notebook of timeline displays
timeline-sequence-handling-test.cpp	Unit test TimelineSequenceHandling_test
timeline-state.cpp	Implementation of presentation state for the first draft of the timeline display
timeline-state.hpp	Presentation state for the first draft of the timeline display
timeline-widget-empty.hpp	Empty placeholder to be rendered when the UI starts without session
timeline-widget.cpp	Implementation details of Lumiera's timeline display widget
timeline-widget.hpp	This file defines the core component of the Lumiera GUI
timeline-zoom-scale.cpp	Widget to control timeline zoom scale
timeline-zoom-scale.hpp	Widget to control timeline zoom scale
timeline.cpp	Implementation functions of the Timeline entity within the Session model
timeline.hpp	Top level structural element within the session
timequant.hpp	Support library to represent grid-aligned time specifications This is part of Lumiera's time and time code handling framework
timevalue.hpp	Family of time value like entities and their relationships
timing-constraints-test.cpp	Unit test TimingConstraints_test
timings-test.cpp
timings.cpp	Implementation of a data tuple for timing specification
timings.hpp	How to define a timing specification or constraint
tmpbuf.c	Implementation of temporary buffers with round-robin usage pattern
tmpbuf.h	Round robin temporary buffers
ToolCCache.py
ToolDistCC.py
toolfactory.cpp	Implementation of factory functions for the tools used within the Builder
toolfactory.hpp	Factory to create the tools for the build process
track-body.cpp	Implementation details regarding display management of the track body area within the timeline display canvas
track-body.hpp	This helper class serves to manage the layout and display of the horizontally extended space of a "track" within the timeline
track-head-widget.cpp	Implementation details regarding display of the track heads within the timeline UI
track-head-widget.hpp	Widget to represent a track head with placement parameters, within the timeline header pane
track-presenter.hpp	Presentation control element to model and manage a track within the timeline UI
track-profile.hpp	Abstraction to build the layout for the track spaces within timeline display
tracking-allocator.cpp	Implementation of the common storage backend for the tracking test allocator
tracking-allocator.hpp	Unittest helper code: a custom allocator to track memory usage
tracking-dummy.hpp	Unittest helper code: test dummy objects to track instances
tracking-heap-block-provider-test.cpp	Unit test TrackingHeapBlockProvider_test
tracking-heap-block-provider.cpp	Implementation details of a mock engine::BufferProvider for unit testing
tracking-heap-block-provider.hpp	Dummy implementation of the BufferProvider interface to support writing unit tests
trait-special.hpp	Rarely used specialisations of otherwise heavily used generic code
trait.hpp	Helpers for type detection, type rewriting and metaprogramming
transiently.hpp	Test helper to perform temporary manipulations within a test scope
transition-widget.cpp	Implementation details of transition UI control
transition-widget.hpp	UI representation of a transition to blend several media elements
tree-diff-application.hpp	Concrete implementation to apply structural changes to hierarchical data structures
tree-diff-traits.hpp	Definitions and Properties to guide automated tree mutator binding
tree-diff.cpp	Implementation of diff application to unspecific private data structures
tree-diff.hpp	A token language to represent structural changes in a tree like hierarchical data structure
tree-mutator-attribute-binding.hpp	Special binding implementation for TreeMutator, allowing to map tree diff operations onto native object attributes
tree-mutator-binding-test.cpp	Unit test TreeMutatorBinding_test
tree-mutator-collection-binding.hpp	Special binding implementation for lib::diff::TreeMutator, allowing to map tree diff operations onto a STL collection of native implementation objects
tree-mutator-diffmutable-binding.hpp	Special supplement for TreeMutator and the STL collection binding, to provide a shortcut and default wiring for a collection holding DiffMutable objects – either directly or by smart-ptr
tree-mutator-gen-node-binding.hpp	Special binding implementation for TreeMutator, allowing to map tree diff operations onto an »External Tree Description«
tree-mutator-listener-binding.hpp	Special supplement for TreeMutator, to attach listeners for notification on specific changes, especially structural ones
tree-mutator-noop-binding.hpp	Special binding implementation for TreeMutator, allowing to accept and ignore any tree diff without tangible effect
tree-mutator-test.cpp	Unit test TreeMutator_test
tree-mutator.hpp	Customisable intermediary to abstract generic tree mutation operations
tuple-diagnostics.hpp	Extension to typelist-diagnostics.hpp, allowing to dump the contents of a Tuple datatype
tuple-helper-test.cpp	Interplay of typelists, type tuples and std::tuple
tuple-helper.hpp	Metaprogramming with tuples-of-types and the std::tuple record
tuple-record-init-test.cpp	Unit test TupleRecordInit_test
tuple-record-init.hpp	Specialised adapter to consume a record of GenNode entries to build a tuple
turnout-system.cpp	Implementation details of some statefull operations needed from within the render calculation
turnout-system.hpp	THe actual state of a frame rendering evaluation parametrised for a single job
turnout.hpp	Fixed standard setup used in each Port of the Render Node to generate data
type-demangling-test.cpp	Unit test TypeDemangling_test
type-display-test.cpp	Unit test TypeDisplay_test
type-handler.hpp	Helper holding a pair of type-build-up and destruction functors
typed-allocation-manager-test.cpp	Unit test TypedAllocationManager_test
typed-allocation-manager.hpp	Abstract foundation for building custom allocation managers
typed-counter-test.cpp	Stress test to verify type-based contexts
typed-counter.hpp	Creating series of type-based contexts
typed-family-member-id-test.cpp	Unit test to verify generation of a Member ID within a type based family of objects
typed-id-test.cpp	Unit test TypedID_test
typed-id.hpp	Frontend for a registration service to associate object identities, symbolic identifiers and types
typed-lookup.cpp	Implementation backend for a registration service to associate IDs, types and object instances
typelist-diagnostics.hpp	Support for writing metaprogramming unit-tests dealing with typelists and flags
typelist-manip-test.cpp
typelist-manip.hpp	Metaprogramming: Helpers for manipulating lists-of-types
typelist-test.cpp	Unit test TypeList_test
typelist-util-test.cpp	Unit test TypeListUtil_test
typelist-util.hpp	Metaprogramming: simple helpers for working with lists-of-types
typelist.hpp	A template metaprogramming technique for manipulating collections of types
typeseq-manip-test.cpp	Verify the proper working of simple type sequence manipulations
typeseq-util.hpp	Some basic facilities for manipulating type sequences
ui-bus.cpp	Implementation of the UI backbone service for messaging
ui-bus.hpp	Under construction: the top level UI controller
ui-coord-resolver-test.cpp	Unit test UICoordResolver_test
ui-coord-resolver.cpp	Implementation details of resolving a UICoord path against the actual UI topology
ui-coord-resolver.hpp	Evaluation of UI coordinates against a concrete window topology
ui-coord-test.cpp	Unit test UICoord_test
ui-coord.hpp	A topological addressing scheme to designate structural locations within the UI
ui-dispatcher.hpp	Allow dispatch of self-contained code blocks (lambdas) into the main UI event thread
ui-location-solver-test.cpp	Unit test UILocationSolver_test
ui-location-solver.hpp	A solver to match incomplete coordinate specifications against the actual UI topology
ui-manager.cpp	Implementation of global concerns regarding a coherent UI and global state
ui-manager.hpp	Manager for global user interface concerns, framework integration and global state
ui-protocol.cpp	Storage for key constants and basic definitions used for interfacing with the GUI
ui-protocol.hpp	Hard wired key constants and basic definitions for communication with the GUI
ui-state.cpp	Implementation of a manager to establish and store global persistent UI state
ui-state.hpp	Establish and handle persistent interface state
ui-style.cpp	Implementation of global concerns regarding a coherent UI and global state
ui-style.hpp	Service for global theming and style related concerns
uninitialised-storage.hpp	A raw memory block with proper alignment and array access
unique-malloc-owner-test.cpp	Unit test UniqueMallocOwner_test
unique-malloc-owner.hpp	Helper to deal with C-MALLOCed memory automatically
unknown.cpp	Implementation functions regarding a marker asset for unknown media
unknown.hpp	Marker Asset to indicate an unknown media source
util-coll.hpp	Some small helpers and convenience shortcuts to ease working with collections and sequences (given by iterator)
util-collection-test.cpp	Unit test UtilCollection_test
util-floordiv-test.cpp	Unit test UtilFloordiv_test
util-floorwrap-test.cpp	Unit test UtilFloorwrap_test
util-foreach-test.cpp	Unit test UtilForeach_test
util-foreach.hpp	Perform operations "for each element" of a collection
util-identity-test.cpp	Unit test UtilIdentity_test
util-parse-bool-test.cpp	Unit test UtilParseBool_test
util-quant.hpp	Utilities for quantisation (grid alignment) and comparisons
util-sanitised-identifier-test.cpp	Unit test UtilSanitizedIdentifier_test
util-tuple-test.cpp	Unit test UtilTuple_test
util-tuple.hpp
util.cpp	Implementation of widely used helper functions
meta/util.hpp	Simple and lightweight helpers for metaprogramming and type detection
util.hpp	Tiny helper functions and shortcuts to be used everywhere Consider this header to be effectively included in almost every translation unit
value-type-binding-test.cpp
value-type-binding.hpp	Type re-binding helper template for custom containers and adapters
variadic-argument-picker-test.cpp	Verify metaprogramming manipulation on a variadic parameter pack
variadic-helper.hpp	Metaprogramming with type sequences based on variadic template parameters
variant-o.hpp	This file defines a simple alternative to boost::variant
variant-test.cpp	Unit test Variant_test
variant.hpp	A typesafe union record to carry embedded values of unrelated type
vcall.h	This allows one to do polymorphic programming in C by referencing a vtable member which contains function pointers to a structure and then calling this 'virtual' functions through the VCALL macro
vector-transfer-test.cpp	Unit test VectorTransfer_test
verb-function-dispatch-test.cpp	Demonstrate the concept of a verb language based on double dispatch
verb-token.hpp	Building blocks for a simple DSL using double dispatch to a handler function
verb-visitor-dispatch-test.cpp	Demonstrate the extended concept of a verb language based on double dispatch
verb-visitor.hpp	A specific double dispatch variation for function invocation
vgsuppression.c	Dummy executable to generate valgrind suppressions
video-display-widget.cpp	Implementation of video display, embedded into the UI
video-display-widget.hpp	Widget to create a video display embedded into the UI
view-hook-test.cpp	Unit test ViewHook_test
view-hook.hpp	Allow widgets to connect to a common shared presentation context
view-locator.cpp	Implementation details of a machinery to allocate UI global component views
view-locator.hpp	Access and allocation of UI component views
view-spec-dsl-test.cpp	Unit test ViewSpecDSL_test
view-spec-dsl.hpp	A framework for configuration of view access and allocation patterns
viewer-panel.cpp	Implementation of a dockable panel to hold the video viewers
viewer-panel.hpp	Definition of a dockable panel to hold the video viewers
viewer.cpp	Implementation functions to represent a viewer or viewer attachment point
viewer.hpp	Structural element corresponding to a viewer in the GUI
virtual-copy-support-test.cpp	Unit test VirtualCopySupport_test
virtual-copy-support.hpp	Helper for building »virtual copy« operations
visitingtool-concept.cpp	While laying the foundations for Session and Builder, Ichthyo came across the necessity to create a custom implementation of the Visitor Pattern optimally suited for Lumiera's needs
visitingtool-extended-test.cpp	Unit test VisitingToolExtended_test
visitingtool-test.cpp	Unit test VisitingTool_test
visitor-dispatcher.hpp	Helper for a trampoline table based implementation of the visitor pattern
visitor-policies.hpp	Policies usable for configuring the lib::visitor::Tool for different kinds of error handling
visitor.hpp	A library implementation of the Visitor Pattern tailored specifically to Lumiera's needs within the Steam Layer
w-link-test.cpp	Unit test WLink_test
w-link.hpp	A smart link to an GTK widget with automatic disconnection
weaving-pattern-builder.hpp	Construction kit to establish an invocation scheme for media calculations
weaving-pattern.hpp	Construction set to assemble and operate a data processing scheme within a Render Node
widget.hpp	Common Abstraction of all UIBus connected widget elements
window-locator.cpp	Implementation details of management and access to all top level windows and docking panels
window-locator.hpp	Manager for all top level application windows
wiringrequest.hpp	Symbolic representation of a goal for node wiring
wish.cpp
wish.hpp
wizard.cpp	Implementation of the global help controller to show the user manual
wizard.hpp	Global help controller
work-force-test.cpp	Unit test WorkForce_test
work-force.cpp	Implementation of render worker coordination
work-force.hpp	A pool of workers for multithreaded rendering
work-site-trail.cpp	Implementation aspects regarding a history of visited work sites
work-site-trail.hpp	History of work sites visited by the user in recent past
work-site.cpp	Implementation aspects of the WorkSite abstraction
work-site.hpp	Represent a place "in" the interface where the user is about to do something
workspace-window.cpp	Implementation of base functionality for workspace windows
workspace-window.hpp	This file contains the definition of the main workspace window parent, which is the toplevel parent of the whole workspace
wrapper.hpp	Library implementation: smart-pointer variations, wrappers and managing holders
wrapperptr.hpp	Wrapper to treat several flavours of smart-pointers uniformly
xvdisplayer.cpp	Implementation of video output via XVideo
xvdisplayer.hpp	Implementation of video output via XVideo
zombie-check-test.cpp	Unit test Singleton_test
zombie-check.hpp	Detector to set off alarm when (re)using deceased objects
zoom-metric.hpp	Implementation building block to get the DisplayMetric as defined through a ZoomWindow
zoom-window-test.cpp	Unit test ZoomWindow_test The timeline uses the abstraction of an »Zoom Window« to define the scrolling and temporal scaling behaviour uniformly
zoom-window.cpp	Common implementation details related to zoom handling and transformation into screen coordinates
zoom-window.hpp	Abstraction: the current zoom- and navigation state of a view, possibly in multiple dimensions