Lumiera  0.pre.03
»edit your freedom«
File List
Here is a list of all documented files with brief descriptions:
 abstract-tangible-test.cppVerify the common base shared by all interface elements of relevance
 abstractmo.cpp
 abstractmo.hpp
 access-casted-o.hppHelper 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.cppUnit test AccessCasted_test
 access-casted.hppHelper 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.hppSetup of global actions for the main menu
 activity-detector-test.cppUnit test ActivityDetector_test
 activity-detector.hppDiagnostic setup to instrument and observe Activity activations
 activity-lang.cppImplementation details of the scheduler activity language framework
 activity-lang.hppA language framework to define and interconnect scheduler activity verbs
 activity-term.hppA term of the activity language describing interconnected scheduler activities
 activity.hppDescriptor for a piece of operational logic performed by the scheduler
 add-clip-test.cppUnit test AddClip_test
 advice-basics-test.cppUnit test AdviceBasics_test
 advice-binding-pattern-test.cppUnit test AdviceBindingPattern_test
 advice-configuration-test.cppUnit test AdviceConfiguration_test
 advice-index-test.cppUnit test AdviceIndex_test
 advice-multiplicity-test.cppUnit test AdviceMultiplicity_test
 advice-situations-test.cppUnit test AdviceSituations_test
 advice.cppImplementation of the AdviceSystem, to support the advice collaboration
 advice.hppExpecting Advice and giving Advice: a cross-cutting collaboration of loosely coupled participants
 allocation-cluster-test.cppUnit test AllocationCluster_test
 allocation-cluster.cppImplementation of memory management helper functions for the render engine model
 allocation-cluster.hppMemory management for the low-level model (render nodes network)
 allocation.cpp
 allocation.hpp
 allocator-handle.hppA front-end/concept to allow access to custom memory management
 alsa.cExample implementation how to access the ALSA sound backend
 alsa.hInterfacing to ALSA sound output
 app-config-test.cppUnit test Appconfig_test
 applicable-builder-target-types.hppDeclaration of all kinds of MObjects to be treated by some "Builder tool"
 appstate.cppImplementation of the main application object of Lumiera
 appstate.hppRegistering and managing primary application-global services
 argument-erasure.hppImplementation helper to bind Steam-Layer commands with arbitrary argument tuples
 argument-tuple-accept-test.cppUnit test ArgumentTupleAccept_test
 argument-tuple-accept.hppMixin-templates providing arbitrary function call operators and argument binding functions
 assembler.cpp
 assembler.hpp
 asset-category-test.cppUnit test AssetCategory_test
 asset-controller.cppImplementation of the asset management UI top level
 asset-controller.hppUser interface for asset management
 asset-diagnostics.hppSmall helper and diagnostic functions related to Asset and AssetManager
 asset.cppDefault implementation of the Asset abstraction
 asset.hppSteam-Layer Interface: Assets
 assetmanager.cppImplementation of Asset lookup and organisation functions
 assetmanager.hppSteam-Layer Interface: Asset Lookup and Organisation
 assets-panel.cppImplementation of a (dockable) panel to organise the assets of a project
 assets-panel.hppA (dockable) panel to organise the assets of a project
 auto.cpp
 auto.hpp
 basic-setup.cppImplementation of self-configuration and bootstrap functionality
 basic-setup.hppBootstrap and self-configuration of the application at startup
 basicpipetest.cppUnit test BasicPipe_test
 bin-widget.cppImplementation details of a media bin UI
 bin-widget.hppWidget to render a media bin display in the Lumiera GUI
 common/advice/binding.cppImplementation of a binding record to represent a match between two patterns
 steam/mobject/session/binding.cppImplementation details of the Binding MObject to tie a sequence into a timeline or virtual clip
 common/advice/binding.hppA pattern to define and identify a specific attachment to the Advice system
 steam/mobject/session/binding.hppMObject in session to represent the top-level binding of a sequence
 block-flow-test.cppUnit test BlockFlow_test
 block-flow.hppMemory management scheme for activities and parameter data passed through the Scheduler within the Lumiera render engine
 body-canvas-widget.cppImplementation details of timeline custom drawing
 body-canvas-widget.hppWidget to render the body of timeline display, by custom drawing into a canvas control
 buff-table-test.cppUnit test BuffTable_test
 buffer-local-key.hppA marker data type used in metadata / buffer management of the render engine
 buffer-metadata-key-test.cppUnit test BufferMetadataKey_test
 buffer-metadata-test.cppUnit test BufferMetadata_test
 buffer-metadata.hppMetadata for managing and accessing buffers
 buffer-provider-protocol-test.cppUnit test BufferProviderProtocol_test
 buffer-provider.cppImplementation details related to buffer lifecycle management in the render engine
 buffer-provider.hppAbstraction to represent buffer management and lifecycle within the render engine
 buffhandle-attach.hppExtension to allow placing objects right into the buffers, taking ownership
 buffhandle.hppA front-end to support the buffer management within the render nodes
 bufftable-obsolete.hpp
 bufftable.hppHelper for organisation of render data buffers Used during the process of _"pulling"_ a render node, which recursively might pull further nodes
 build-segment-test.cppUnit test BuildSegment_test
 builder-qualifier-support-test.cppUnit test lib::test::BuilderQualifierSupport_test
 builder-qualifier-support.hppMix-in to support builder functions to accept optional qualifier terms
 builder-tool-test.cppUnit test BuilderTool_test
 BuilderDoxygen.py
 builderfacade.cppImplementation of top-level access to builder functionality
 builderfacade.hppSteam-Layer Facade: access to the Builder
 BuilderGCH.py
 buildertool.hppVisiting-tool mechanism configured specifically for the Builder
 Buildhelper.py
 buildinstruct.hppHelper classes used by asset::ProcPatt to represent the processing information
 bus-mo.cppImplementation details for a processing pipe representation in the Session model
 bus-mo.hppMObject in the Session to represent a processing pipe
 bus-term-test.cppUnit test BusTerm_test
 bus-term.hppAttachment point to the UI-Bus
 button-bar.cppImplementation of a toolbar with buttons for use in dialogs
 button-bar.hppA toolbar widget for use in dialogs
 cairo-util.cppImplementation of helper functions to support working with lib Cairo
 cairo-util.hppUtility functions for working with elements from the Cairo vector drawing library
 calc-stream-test.cppUnit test CalcStream_test
 calc-stream.hppA core abstraction within the render engine to represent an ongoing calculation
 call-queue-test.cppUnit test CallQueue_test
 call-queue.hppA Queue for function invocations, allowing them to be dispatched on demand
 canvas-hook-test.cppUnit test CanvasHook_test
 canvas-hook.hppSpecialised (abstracted) presentation context with positioning by coordinates
 category.cppImplementation parts regarding Asset categorisation
 category.hppDefinition of Asset categorisation
 channel-descriptor.hppRepresentation of the Media type of a data channel used within the engine
 clip-presenter.hppPresentation control element to model and manage a clip within the timeline UI
 clip-widget.cppImplementation details of clip display within the Lumiera UI
 clip-widget.hppThis widget provides the concrete rendering of a clip-like entity
 asset/clip.cppClip Asset implementation
 mobject/session/clip.cppImplementation details regarding a media clip as integrated into the edit / session model
 asset/clip.hppDefinition of Asset representation for a media clip
 mobject/session/clip.hppMObject in the Session to represent a clip on the timeline
 cmd-context-test.cppUnit test CmdContext_test
 cmd-context.cppImplementation details of support for context-bound commands
 cmd-context.hppAbstraction: support for binding command invocation into an UI context
 cmd.hppCommon ID definitions for Steam-Layer commands
 cmdline-wrapper-test.cppUnit test CmdlineWrapper_test
 cmdline.cppImplementation of a wrapper / marker to handle "commandline arguments"
 cmdline.hppClass to encapsulate the typical C-style commandline definition
 codec.hppDefinition of a Codec Asset
 command-argument-test.cppUnit test CommandArgument_test
 command-basic-test.cppUnit test CommandBasic_test
 command-binding-test.cppUnit test CommandBinding_test
 command-clone-builder-test.cppUnit test CommandCloneBuilder_test
 command-closure.hppA closure enabling self-contained execution of commands within the SteamDispatcher
 command-def.hppActually defining a command and binding it to execution parameters
 command-dispatch.hppInterface to abstract the SteamDispatcher's ability to handle command messages
 command-equality-test.cppUnit test CommandEquality_test
 command-impl-clone-builder.hppHelper for creating an implementation clone, based on the visitor pattern
 command-impl.hppTop level of the command implementation
 command-instance-manager-test.cppUnit test CommandInstanceManager_test
 command-instance-manager.hppService to support forming and invocation of command instances for use by the UI
 command-invocation.hppSome additional helpers and convenience shortcuts to ease command invocation
 command-message-binding-test.cppUnit test CommandMessageBinding_test
 command-mutation-test.cppUnit test CommandMutation_test
 command-mutation.hppCore of a Steam-Layer command: functor containing the operation to be executed
 command-op-closure.hppImplementation 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.hppImplementation building block of SteamDispatcher to organise commands
 command-registry-test.cppUnit test CommandRegistry_test
 command-registry.hppManaging command definitions and the storage of individual command objects
 command-setup-test.cppUnit test CommandSetup_test
 command-setup.cppImplementation details of instance management for command invocation by the GUI
 command-setup.hppProvision for setup of concrete commands for use by the UI
 command-signature.hppMetaprogramming helpers for deriving the precise function signatures necessary to implement a given command
 command-simple-closure.hppProof-of-concept implementation of CmdClosure
 command-storage-holder.hppA passive container record holding the actual command arguments & UNDO state
 command-use1-test.cppUnit test CommandUse1_test
 command-use2-test.cppUnit test CommandUse2_test
 command-use3-test.cppUnit test CommandUse3_test
 command.cppImplementation of the command frontend
 command.hppSteam-Layer command frontend
 common-services.cppWire library facilities directly into application core services This translation unit serves to complete the definition of some parts of the Lumiera library
 steam/common.hppBasic set of definitions and includes commonly used together
 steam/mobject/builder/common.hpp
 vault/common.hppBasic set of definitions and includes commonly used together (Vault)
 compoundmedia.hppDefinition of an Asset to represent a clustering or compound of several media
 compoundmediatest.cppUnit test CompoundMedia_test
 config-facade.hThe lumiera::Config wrapper class addresses two issues
 config-flags-test.cpp
 config-interface.cA public interface to a (planned) global configuration system
 config-interface.hExternal interface to the lumiera configuration system
 config-keys.cpp
 config-keys.hppDefinition of access keys for global UI configuration
 config-lookup.cImplementation draft for a configuration system (2008)
 config-lookup.hLookup of configuration keys in a low-level configuration system
 config-resolver.cppImplementation of bindings between Steam-Layer objects and rules-based configuration
 config-resolver.hppDefinition of the concrete frontend for rule based configuration within the session
 config-rules.cppImplementation backend part for a configuration rules / query system
 config-rules.hppInterface for accessing rule based configuration
 config-typed.cImplementation draft for a configuration system (2008)
 config-wordlist.cDraft for a configuration system (2008)
 config.cImplementation of a draft for application configuration from 2008
 config.hInterface for a lumiera configuration system (draft)
 configentry.cDraft for a configuration system (2008)
 configentry.hDraft for a configuration system (2008)
 configfacade.cppDraft 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.hppUnder some circumstances it is necessary to assemble functionality out of elementary building blocks
 configitem.cImplementation draft for a configuration system (2008)
 configitem.hDraft for a configuration system (2008)
 conmanager.cpp
 conmanager.hpp
 constraint.cpp
 constraint.hppSpecialised LocatingPin for use in placements
 control-impl.hppImplementation building blocks for time modification and propagation
 control-policy.hppDefinition of special cases when imposing a change onto concrete time values
 control.hppManipulating and monitoring time entities with life changes
 controller.hppCommon Abstraction of all sub-controller, coordinated by the UI-Bus
 controllerfacade.hppUnfinished draft for a "Steam-Layer Controller"
 core-service.hppDedicated service node within the UI-Bus to handle command invocation and presentation state
 create-asset-test.cppUnit test CreateAsset_test
 custom-shared-ptr-test.cppUnit test CustomSharedPtr_test
 dataset.hppDefinition of an Asset to represent a set of control data An example would be captured animation data from some kind of external controller
 db.hppImplementation of the Asset database
 defs-manager-impl-test.cppUnit test DefsManagerImpl_test
 defs-manager-impl.hppImplementation of the core defaults-management operations
 defs-manager-test.cppUnit test DefsManager_test
 defs-manager.hppManagement of defaults and default rules
 defs-registry-impl-test.cppUnit test DefsRegistryImpl_test
 defs-registry.hppA piece of implementation code factored out into a separate header (include)
 del-stash-test.cppUnit test DelStash_test
 del-stash.hppCollecting and finally triggering deleter functions
 deleteassettest.cppUnit test DeleteAsset_test
 deletecliptest.cppUnit test DeleteClip_test
 depend-inject.hppPer type specific configuration of instances created as service dependencies
 depend.hppSingleton services and Dependency Injection
 dependency-configuration-test.cppUnit test DependencyConfiguration_test
 dependency-factory-test.cppUnit test DependencyFactory_test
 dependent-assets-test.cppUnit test DependentAssets_test
 diagnostic-buffer-provider.cppImplementation details of unit test support regarding internals of the render engine
 diagnostic-buffer-provider.hppA facility for writing unit-tests targeting the BufferProvider interface
 diagnostic-context-test.cppUnit test DiagnosticContext_test
 diagnostic-context.hppFacility for collecting diagnostic context information explicitly
 diagnostic-output-slot.hppAn facility for writing unit-tests against the OutputSlot interface
 diagnostic-output.hppHelpers typically used while writing tests
 diagnostics.hppExtension to the lib::time::Time wrapper, adding output and further diagnostic aids
 dialog.hppGlobal constants and definitions for dialogs
 diff-complex-application-test.cppUnit test DiffComplexApplication_test
 diff-ignore-changes-test.cppUnit test DiffIgnoreChanges_test
 diff-index-table-test.cppUnit test DiffIndexTable_test
 diff-language.hppFundamental definitions for a representation of changes
 diff-list-application-test.cppUnit test DiffListApplication_test
 diff-list-generation-test.cppUnit test DiffListGeneration_test
 diff-mutable.hppAbstraction or descriptor interface for a data structure exposing the ability for mutation by receiving diff messages
 diff-tree-application-simple-test.cppUnit test DiffTreeApplicationSimple_test
 diff-tree-application-test.cppUnit test DiffTreeApplication_test
 diff-tree-mutation-listener-test.cppUnit test DiffTreeMutationListener_test
 diff.cppDiff handling framework support code
 digxel-configurations-test.cppUnit test DigxelConfigurations_test
 digxel-test.cppUnit test Digxel_test
 digxel.hppA self-contained numeric element for building structured numeric displays
 dispatch-table.cppImplementation details of render job generation
 dispatch-table.hppImplementation details of render job generation
 dispatcher-interface-test.cppUnit test DispatcherInterface_test
 dispatcher-looper-test.cpp
 dispatcher.cppImplementation parts of job generation within an ongoing render process
 dispatcher.hppService abstraction within the render engine for generating render jobs
 display-evaluation.cppImplementation details of collaborative and global timeline display allocation
 display-evaluation.hppA collaboration to establish a globally coherent timeline display layout
 display-facade.hExperimental Interface, allowing the Dummy-Player to access the video display widget in the GUI
 display-handles.hOpaque handles and similar typedefs used to communicate via the lumiera::Display and lumiera::DummyPlayer facade interfaces
 display-interface-proxy.cppInterface-Proxy for the lumiera::Display facade (experimental/deprecated)
 display-manager.cppImplementation details regarding timeline layout management and widget coordination
 display-manager.hppAbstraction: service for the widgets to translate themselves into screen layout
 display-service.cppImplementation of Displayer Service, exposed as a public interface
 display-service.hppA public service provided by the GUI, implementing the lumiera::Display facade interface
 displayer.cppImplementation of a displayer object, intended for creating a video display in the UI
 displayer.hppThe Displayer serves as base of all video display implementations
 dock-area.cppImplementation of dockable UI panels, implemented with the help of lib GDL (»Gnome Docking Library«, formerly aka »Gnome Design Library«)
 dock-area.hppManagement of dockable panels within each top-level WorkspaceWindow
 drag-relocate-controller.hppConcrete implementation of a dragging gesture to relocate an UI entity
 duck-detector-extension-test.cppUnit test DuckDetectorExtension_test
 duck-detector-test.cppUnit test DuckDetector_test: duck typing through metaprogramming
 duck-detector.hppMetaprogramming helpers to check for specific properties of a type in question
 dummy-builder-context.hppSimulated result of a builder run for test purposes, without actual session and model content
 dummy-functions.hppDummy functions to support unit testing of function metaprogramming helpers
 dummy-image-generator.cppImplementation of a generator for dummy video frames for a mockup
 dummy-image-generator.hppGenerator for test dummy video frames to simulate playback of rendered output
 dummy-play-connection-test.cppUnit test DummyPlayConnection_test
 dummy-play-connection.cppImplementation of a service for mock render playback to support testing
 dummy-play-connection.hppDummy and test setup of playback and rendering, omitting most of the Lumiera engine
 dummy-player-facade.h
 dummy-player-interface-proxy.cppInterface-Proxy for the lumiera::DummyPlayer facade (experimental/obsolete)
 dummy-player-service.cppImplementation of a service for mock render output to support testing
 dummy-player-service.hppA public service provided by the Steam-Layer, implementing a dummy/mockup playback process
 dummy-session-connection.cppImplementation details to build some scaffolding for UI<–>Session integration
 dummy-session-connection.hppDummy and scaffolding to help development of the UI - Session connection
 dummy-tick.hppA timer service invoking a given callback periodically
 asset/effect.cppImplementation level functionality regarding the Asset representation of effects
 mobject/session/effect.cpp
 asset/effect.hppDefinition of an Asset representation for any kind of effect or media processor
 mobject/session/effect.hpp
 elem-access-dir.hppA service to discover and access raw UI elements in a cross cutting way
 element-access-test.cppUnit test ElementAccess_test
 element-access.hppInterface to discover and access raw UI elements in a cross cutting way
 element-box-widget.cppImplementation details of the UI building block to display an ID label
 element-box-widget.hppWidget to render an ID label with associated icon
 element-query.hppSearch and query services to discover contents of the session
 element-tracker.hppTracking instances automatically on creation and disposal
 engine-config.cppImplementation of engine configuration and parametrisation
 engine-config.hppAccess point to configuration of engine parameters
 engine-diagnostics.hppAn facility to check and monitor engine operations
 engine-interface-test.cppUnit test EngineInterface_test
 engine-observer.hppRender Engine performance data collection service
 engine-service-mock.cppImplementation translation unit for a mock render engine for unit testing
 engine-service-mock.hppPlaceholder implementation of the render engine for test and diagnostics
 engine-service.cppImplementation parts related to the engine service abstraction
 engine-service.hppAccess point for the (core) calculation service of the render engine
 enginefacade.cppSubsystem descriptor and configuration for the render engine
 enginefacade.hppGlobal control interface for the render engine subsystem
 entry-id-test.cppUnit test EntryID_test
 entry-id.hppBare symbolic and hash ID used for accounting of asset like entries
 error-exception.cppImplementation of C++-style error handling
 error-log-display.hppWidget to display error messages to be accessible in non-modal way
 error-log.cppImplementation details of incident logging and persistence
 error-log.hppAn entity to collect, possibly filter and persist incident records
 error-state.cImplementation of C-style error handling in Lumiera
 error.hLumiera error handling (C interface)
 error.hppLumiera error handling (C++ interface)
 event-log-test.cppUnit test EventLog_test
 event-log.cppImplementation details of event logging and verification for unit tests
 event-log.hppSupport for verifying the occurrence of events from unit tests
 example-plugin.cDummy 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.cppDummy 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.cppUnit test ExceptionError_test
 exit-node.hppEffective top-level exit point to pull rendered data from the nodes network
 expander-revealer.hppHelper components to implement some standard UI-element actions by installing a functor
 explicitplacement.hppCore 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.cppUnit test ExtentFamily_test
 extent-family.hppMemory management scheme for cyclically used memory extents
 facade.cppImplementation of subsystem lifecycle behaviour for the core parts of Steam-Layer
 stage/ctrl/facade.hpp
 steam/facade.hpp
 fake-configrules.cppImplementation of a fake query resolution service based on preconfigured answers
 fake-configrules.hppMock/Test/Debugging Implementation of the config rules system
 fixedlocation.cpp
 fixedlocation.hppSpecialised 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.cppUnit test FixtureChangeDetector_test
 fixture-change-detector.hppWork out the part of the Fixture changed by a build process
 fixture-segment-test.cppUnit test FixtureSegment_test
 fixture.cppImplementation of the Fixture datastructure
 fixture.hppBackbone 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.hppDecorator to add the ability to display a visual flash action to a GTK widget
 focus-tracker.cppImplementation helper functionality to link the global activity spot to typical UI focus and activation changes
 focus-tracker.hppHelper to track focus/activation changes to move the activity "Spot" automatically
 fork.cppImplementation of the basic grouping device within the session ("Track" / "Media Bin")
 fork.hppOrganisational grouping device within the Session model ("Track" / "Media Bin")
 format-cout-test.cppUnit test FormatCOUT_test
 format-cout.hppAutomatically use custom string conversion in C++ stream output
 format-helper-test.cppUnit test FormatHelper_test
 format-obj.cppSome implementation helpers for simple object display
 format-obj.hppSimple functions to represent objects, for debugging and diagnostics
 format-string-test.cppUnit test FormatString_test
 format-string.cppImplementation for printf-style formatting, based on boost::format
 format-string.hppFront-end for printf-style string template interpolation
 format-support-test.cppUnit test FormatSupport_test
 format-util.hppCollection of small helpers and convenience shortcuts for diagnostics & formatting
 formats.hppDefinition 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.hppMarker tuple to identify a specific frame
 function-closure-test.cppTesting a combination of std::function objects and metaprogramming
 function-closure.hppPartial function application and building a complete function closure
 function-composition-test.cppUnit test FunctionComposition_test
 function-erasure-test.cppUnit test FunctionErasure_test
 function-erasure.hppGeneric holder for functor objects, concealing the concrete function type
 function-signature-test.cppUnit test FunctionSignature_test
 function.hppMetaprogramming tools for transforming functor types
 gdkdisplayer.cppDysfunctional implementation code, formerly used to create a video display based on GDK
 gdkdisplayer.hppDisplay video via GDK
 gen-node-location-query.hppImplementation of the stage::interact::LocationQuery interface to work on a GenNode tree
 gen-node-test.cppUnit test GenNode_test
 gen-node.cppGeneric node element (implementation parts)
 gen-node.hppGeneric building block for tree shaped (meta)data structures
 generator-combinations-test.cppUnit test GeneratorCombinations_test
 generator-combinations.hppMetaprogramming facilities to generate combination cases
 generator-mo.cpp
 generator-mo.hppA data generator media object
 generator-test.cpp
 generator.hppHelpers for working with lib::meta::Types (i.e
 generic-id-function-test.cppUnit test GenericIdFunction_test
 generic-record-test.cppUnit test GenericRecord_test
 genfunc.cppImplementation of generic functions to build identification schemes
 genfunc.hppGeneric functions to build identification schemes
 gesture-state.cppImplementation of a holder and manager for interaction state
 gesture-state.hppSub-Service of the InteractionDirector: Hold and maintain InteractionState
 global-ctx.hppDependency context to hold all the global UI top-level entities
 grid.hppDefinition of a time grid abstraction for time and timecode handling
 gtk-base.hppA set of basic GTK includes for the UI
 gtk-lumiera.cppStart up the Lumiera GTK GUI when loading it as dynamic module
 gui-notification-facade.hMajor public Interface of the Lumiera GUI
 guifacade.cppImplementation of the GUI loader
 guifacade.hppInterface for the GUI loader and for accessing the GUI interface from the lower layers of Lumiera
 handle.hppA generic opaque handle to an implementation entity, including lifecycle management
 handling-pattern-basics-test.cppUnit test HandlingPatternBasics_test
 handling-pattern-standard-impl-test.cppUnit test HandlingPatternStandardImpl_test
 handling-pattern.cppImplementation of pre-defined command handling patterns
 handling-pattern.hppPre-defined command execution skeletons
 handling-patterns.hppA hard wired collection of predefined command handling patterns
 hash-fnv.cImplementation of FNV ("Fowler-Noll-Vo") hashing functions
 hash-fnv.hFowler-Noll-Vo Hashes
 hash-generator-test.cppUnit test HashGenerator_test
 hash-indexed-test.cppUnit test HashIndexed_test
 hash-indexed.hppA template for generating hash based ID tags carrying compile-time type info
 hash-standard-to-boost-bridge-test.cppUnit test HashStandardToBoostBridge_test
 hash-standard.hppHelper to use a single extension point for specialised hash functions
 hash-value.hHash value types and utilities
 header-pane-widget.hppWidget to show an always visible track header area within the timeline UI
 hello-bug-test.cppUnit test HelloBug_test
 hello.cExample file to demonstrate integration of stand-alone tools into the build process
 helloworldtest.cppUnit test HelloWorld_test
 IconSvgRenderer.py
 id-scheme.hppHard wired definitions for the object identification system used within the UI
 identity-of-assets-test.cppUnit test IdentityOfAssets_test
 index-table.hppGeneric lookup table for a sequence of unique values
 index.hppImplementation datastructure for use by the Advice system
 infobox-panel.cppImplementation of a (dockable) panel to display and manipulate parameters
 infobox-panel.hppA (dockable) panel to display and manage information and parameters
 instancehandle.hppA handle template for automatically dealing with interface and plugin registration and deregistration
 interaction-director.cppImplementation parts of the top-level controller within the UI
 interaction-director.hppThe top-level controller to connect model and user interaction state
 interaction-state.cppCommon base implementation for UI state tracking components
 interaction-state.hppAbstraction: a component to watch, maintain and guide UI state
 interface-descriptor.hA data record to describe interface, interface instances and plug-in instances
 interface.cImplementation: handling of interfaces (extension points)
 interface.hLumiera interface macros and structures
 interfaceproxy.hppImplementation of C++ binding proxies on top of the (plain-C based) interface system
 interfaceregistry.cInterface instances are published and activated by registering them into a global registry, which is defined here
 interfaceregistry.hGlobal registry for interfaces (extension points)
 interpolator.hppCore 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.hppExposing an ID registration cluster as a Meta Asset
 ios-savepoint-test.cppUnit test IosSavepoint_test
 ios-savepoint.hppCapture previous settings of an std::ostream and restore them when leaving scope
 item-wrapper-test.cppUnit test ItemWrapper_test
 iter-adapter-ptr-deref.hppExtension adapter for Lumiera Forward Iterators to dereference any pointer values automatically
 iter-adapter-stl-test.cppUnit test IterAdapterSTL_test
 iter-adapter-stl.hppPreconfigured adapters for some STL container standard usage situations
 iter-adapter-test.cppUnit test IterAdapter_test
 iter-adapter.hppHelper template(s) for creating Lumiera Forward Iterators
 iter-chain-search-test.cppUnit test IterChainSearch_test
 iter-chain-search.hppEvaluation mechanism to apply a sequence of conditions onto a linear search
 iter-cursor-test.cppUnit test IterCursor_test
 iter-cursor.hppAn iterator with the ability to switch direction
 iter-explorer-test.cppThe IterExplorer_test covers and demonstrates a generic mechanism to expand and evaluate tree like structures
 iter-explorer.hppBuilding tree expanding and backtracking evaluations within hierarchical scopes
 iter-queue-test.cppUnit test IterQueue_test
 iter-source-test.cppUnit test IterSource_test
 iter-source.hppExtension module to build an opaque data source, accessible as Lumiera Forward Iterator
 iter-stack-test.cppUnit test IterStack_test
 iter-stack.hppConveniently iterable stack and queue containers
 iterable-classification-test.cppUnit test IterableClassification_test
 itertools-test.cppUnit test IterTools_test
 itertools.hppHelpers for working with iterators based on the pipeline model
 jack-output.cpp
 jack-output.hpp
 job-hash-test.cppUnit test JobHash_test
 job-planning-pipeline-test.cppUnit test JobPlanningPipeline_test
 job-planning-test.cppUnit test JobPlanning_test
 job-planning.hppAggregation of planning data to generate actual frame calculation jobs
 job-ticket.cppImplementation details of preparing and performing job invocations
 job-ticket.hppExecution plan to generate render jobs within a specific render process
 job.cppImplementation of render job invocation
 job.hDefinition of a render job
 label.cpp
 label.hppA marker or reference point in the Session
 late-bind-instance-test.cppUnit test LateBindInstance_test
 libgavl.cppImplementation details of using the GAVL library for processing
 libgavl.hppConcrete implementation of the MediaImplLib facade to work with libGAVL
 life-cycle-test.cppUnit test LifeCycle_test
 lifecycle-advisor.hppImplementation facility providing an operation skeleton of session lifecycle
 lifecycle.cppImplementation of installable callbacks for lifecycle events
 lifecycle.hInstalling and invoking of application lifecycle event callbacks
 lifecycleregistry.hppHelper for registering lifecycle event callbacks, which are provided as a global service by lumiera::AppState
 limits.hHard wired safety limits
 linked-elements-test.cppUnit test LinkedElements_test
 linked-elements.hppIntrusive single linked list with optional ownership
 list-diff-application.hppApply a "list diff" to a concrete sequence of elements in a container
 list-diff-detector.hppCompare two data sequences to find or describe differences
 list-diff.hppA token language to represent changes in a list of elements
 llist.hIntrusive cyclic double linked list There is only one node type which contains a forward and a backward pointer
 load-controller.hppScheduler resource usage coordination
 locatingpin.cppImplementation of the query resolving mechanics within a Placement
 locatingpin.hppImplementing the Placement mechanics
 lockerror.cImplementation and definitions for error-handling on low-level locking
 lockerror.hDefinitions and declarations for error-handling on low-level locking
 logging.hThis header is for including and configuring NoBug
 looper.hppImplementation building block of SteamDispatcher to control waiting and timing
 luid.cImplementation functions for Lumiera's unique object identifier (LUID)
 luid.hLumiera unique object identifier
 luidgen.cGenerate a fixed LUID to be hard-wired into source code
 LumieraEnvironment.py
 main.cA stand alone application to test integration with output frameworks
 main.cppLumiera application main function
 make-clip-test.cppUnit test MakeClip_test
 marker-widget.cppImplementation of marker display
 marker-widget.hppWidget to show a marker at various places
 mask.cppMask generator node implementation
 mask.hppSpecialised render node for generating mask (alpha channel) data
 maybe-compare.hppHelpers for fail-safe invocation of comparison operations from generic code
 media-access-facade.cppImplementation binding to query for a media file's properties
 media-access-facade.hppAbstraction interface to query for a media file
 media-access-mock-test.cppUnit test MediaAccessMock_test
 media-access-mock.cppMock implementation of the Interface normally used to query media file information from the data backend
 media-access-mock.hppUnit test helper to access an emulated media file
 media-impl-lib.hppAbstraction 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.cppUnit test MediaStructureQuery_test
 media.cppImplementation regarding the Media Asset abstraction
 media.hppMedia data represented a specific kind of Asset
 memento-tie-test.cppUnit test MementoTie_test
 memento-tie.hppA special binding used by Steam-Layer commands for capturing UNDO state information
 menu-button.cppImplementation of the MenuButton widget, to display a menu when clicked
 menu-button.hppA button widget that displays a menu when clicked
 meta-cmd.cppActual definition of Steam-Layer command scripts for meta/ctrl actions
 meta-utils-test.cppUnit test MetaUtils_test
 asset/meta.cppImplementation details regarding the Meta Asset category
 mobject/session/meta.cppImplementation details regarding the Meta asset abstraction
 asset/meta.hppInternal and organisational metadata
 mobject/session/meta.hppIntermediate Asset interface: metadata and processing instructions
 microbenchmark.hppFunctions to perform (multithreaded) timing measurement on a given functor
 mini-button.hppAdapter to wrap button widgets intended to serve as tool buttons
 mixer-widget.cppImplementation details of a mixing desk control
 mixer-widget.hppWidget to render a channel mixer within the Lumiera GUI
 mobject-interface-test.cppUnit test MObjectInterface_test
 mobject-ref-test.cppUnit test MObjectRef_test
 mobject-ref.cppImplementation part of the MObjectRef facility
 mobject-ref.hppExternal MObject/Placement reference
 mobject.cppTop level implementation functions globally relevant to the session model
 mobject.hppCore abstraction of the Session model: a media object
 mobjectfactory.cpp
 mobjectfactory.hppCore factory to generate media objects for use in the Session model
 mock-dispatcher.cppImplementation of a dummy render job for unit tests
 mock-dispatcher.hppMock data structures to support implementation testing of render job planning and frame dispatch
 mock-elm.hppA generic interface element instrumented for unit testing
 mock-support-test.cppUnit test MockSupport_test
 model-port-registry-test.cppUnit test ModelPortRegistry_test
 model-port-registry.cppImplementation details of model port descriptors and references
 model-port-registry.hppMutation and management facility for model ports within the builder
 model-port.hppOrganising the output data calculation possibilities
 mould.hppBuilder tool kit
 multifact-argument-test.cppUnit test MultiFactArgument_test
 multifact-singleton-test.cppUnit test MultiFactSingleton_test
 multifact-test.cppUnit test MultiFact_test
 multifact.hppFramework for building a configurable factory, to generate families of related objects
 mutation-message-test.cppUnit test MutationMessage_test
 mutation-message.hppGeneric Message with an embedded diff, to describe changes to model elements
 mutation.cppA collection of concrete forms of time mutation
 mutation.hppModifying time and timecode values
 mutex.cMutual exclusion locking
 mutex.hMutual exclusion locking, header
 name-chooser.cppImplementation details of NameChooser, a dialog to enter a name string
 name-chooser.hppDialog to enter a string name
 navigator-widget.cppImplementation detail of the navigation control elements presented at top of the timeline UI's header pane
 navigator-widget.hppWidget for navigation controls within the timeline UI
 navigator.cppImplementation of global interface navigation mechanisms
 navigator.hppGlobal interface navigation control
 netnodefacade.cppSubsystem descriptor and configuration for a renderfarm node
 netnodefacade.hppGlobal control interface for running Lumiera as a renderfarm node
 nexus.hppCore hub and routing table of the UI-Bus
 no-instance.hppMetaprogramming helper to prevent an entity to be ever instantiated at runtime
 nobug-init.cppImplementation function for automatic trigger of NoBug initialisation
 nobug-init.hppTrigger the basic NoBug initialisation by placing a static variable
 nobug-resource-handle-context.hppThread-local stack of NoBug resource handles
 nocopy.hppMix-Ins to allow or prohibit various degrees of copying and cloning
 node-basic-test.cppUnit test NodeBasic_test
 node-fabrication-test.cppUnit test NodeFabrication_test
 node-graph-attachment-test.cppUnit test NodeGraphAttachment_test
 node-graph-attachment.hppLink from the Fixture datastructure into the render node network
 node-operation-test.cppUnit test NodeOperation_test
 node-source-test.cppUnit test NodeSource_test
 nodecreatortool.cppImplementation of visitor logic to actually build the render node network
 nodecreatortool.hppVisitor tool to work on the concrete model objects when building the render node network
 nodefactory.cppImplementation of render node setup and wiring
 nodefactory.hppA factory to build processing nodes
 nodeinvocation.hppOrganise 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.hppChunks of operation for invoking the rendernodes
 nodewiring-config.hppSometimes we need to choose a different implementation for dealing with some special cases
 nodewiring-def.hppHelper for defining the desired wiring and operation mode for a render node
 nodewiring.cppImplementation of node wiring to build a render node network
 nodewiring.hppMechanism to wire ProcNode instances for a render network
 nop-job-functor.hppGeneric implementation of a JobFunctor to perform no calculations
 notification-hub.hppController to receive and handle notification messages for the user
 notification-interface-proxy.cppInterface-Proxy for the stage::GuiNotification facade
 notification-service.cppImplementation of notifications and updates within the GUI
 notification-service.hppA public service provided by the GUI, implementing the stage::GuiNotification facade interface
 null-value-test.cppUnit test NullValue_test
 null-value.hppSingleton-style holder for NIL or default values
 opaque-holder-test.cppUnit test OpaqueHolder_test
 opaque-holder.hppHelper allowing type erasure while holding the actual object inline
 opaque-unchecked-buffer-test.cppUnit test OpaqueUncheckedBuffer_test
 operationpoint.cppImplementation of primitive builder operations on at the current point of operation
 operationpoint.hppAbstraction to represent the current point of operation within the builder
 option.cppImplementation of commandline argument handling, based on lib Boost »program options«
 option.hppFront-end for handling the commandline arguments
 optional-ref-test.cppUnit test OptionalRef_test
 optional-ref.hppChecked, switchable reference
 Options.py
 ordering-of-assets-test.cppUnit test OrderingOfAssets_test
 output-designation.cppImplementation details of OutputDesignation and OutputMapping
 output-designation.hppCore abstraction: symbolic representation of some output target
 output-director.cppImplementation of global output connection management
 output-director.hppA global service to coordinate and handle all external output activities
 output-manager.hppA global service to handle all external output connections
 output-mapping-test.cppUnit test OutputMapping_test
 output-mapping.hppTranslating and wiring output designations
 output-slot-connection.hppInterface for concrete output implementations to talk to the OutputSlot frontend
 output-slot-protocol-test.cppUnit test OutputSlotProtocol_test
 output-slot.cppGeneric implementation functionality common to all output connections
 output-slot.hppAn (abstract) capability to send media data to an external output
 p.hppCustomised refcounting smart pointer
 panel-bar.cppImplementation of a custom container widget to place toolbar buttons into the active docking header area of GDL docking panels
 panel-bar.hppCustom container widget to allow placing toolbar buttons into the active docking header area of GDL docking panels
 panel-locator.hppAccess and query front-end to locate, access and place docking panels
 panel-manager.cppImplementation of dockable UI panels, implemented with the help of lib GDL (»Gnome Docking Library«, formerly aka »Gnome Design Library«)
 panel-manager.hppManagement of dockable panels
 panel.cppImplementation base for all dockable panels
 panel.hppBase class and interface for all dockable panels
 parameter.cppImplementation functions of the Parameter abstraction
 parameter.hppCore abstraction: parameter to be controlled and possibly automated
 paramprovider.cppImplementation functions of the Parameter abstraction
 paramprovider.hppCore abstraction: an entity to expose a single parameter
 patchbay-widget.cppImplementation details of the patchbay, allowing to tweak parameters of a fork's placement
 patchbay-widget.hppWidget to hold the track head controls within the timeline header pane UI
 path-array-test.cppUnit test PathArray_test
 path-array.hppFoundation abstraction to implement path-like component sequences
 pathmanager.cppImplementation functionality regarding decision about the proper wiring and calculation strategy for rendering
 pathmanager.hppFacility to decide upon the actual render strategy
 pipe-widget.cppImplementation details of a pipe configuration UI
 pipe-widget.hppA component to show and manipulate the processing pipe configuration
 pipe.cppImplementation details regarding the Asset representation of a processing Pipe
 pipe.hppA "processing pipe" represented as Asset
 placeholder-command.hppGenerate fake commands with stub operations and the ability to verify invocation
 placement-basic-test.cppUnit test PlacementBasic_test
 placement-hierarchy-test.cppUnit test PlacementHierarchy_test
 placement-index-query-resolver.cpp
 placement-index-query-resolver.hppImplementing resolution of "discover contents"-queries based on PlacementIndex
 placement-index-query-test.cppUnit test PlacementIndexQuery_test
 placement-index-test.cppUnit test PlacementIndex_test
 placement-index.cppImplementation of core session storage structure
 placement-index.hppCore of the session implementation datastructure
 placement-object-identity-test.cppUnit test PlacementObjectIdentity_test
 placement-ref-test.cppUnit test PlacementRef_test
 placement-ref.hppA generic reference mechanism for Placements, as added to the current session
 placement-scope-test.cppUnit test PlacementScope_test
 placement.cppImplementation functions belonging to the Placement entity
 placement.hppCore abstraction: placement of a media object into session context
 Platform.py
 play-controller.cppImplementation of the control- / management frontend(s) exposed to clients for talking to an ongoing PlayProcess
 play-controller.hppFunctionality for driving and controlling an ongoing playback or render
 play-facade.hppPublic access point to the playback service provided by the »play-out subsystem«
 play-process.cppImplementation to organise an ongoing playback/rendering process
 play-process.hppOrganisational unit of an ongoing render- or playback process
 play-service.cppImplementation of core parts of the Player subsystem
 play-service.hppPrimary service of the Player subsystem: Starting and controlling render/playback
 playback-controller.cppImplementation parts of PlaybackController
 playback-controller.hppThis file contains the definition of the playback controller object
 player-widget.cppImplementation details of the playback control widget
 player-widget.hppWidget to render the typical playback control element in the UI
 plug.cpp
 plug.hpp
 plugin-dynlib.cImplementation of plugin loader for dynamic libraries
 plugin.cPlugin loader implementation
 plugin.hLumiera 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.cppUnit test PolymorphicValue_test
 polymorphic-value.hppA mechanism to allow for opaque polymorphic value objects
 ppmpl.hPreprocessor metaprogramming library
 preferences-dialog.hppDialog to manage application preferences
 preview.cppImplementation details regarding a placeholder / "Proxy" / preview media asset
 preview.hppPlaceholder "proxy" Asset
 proc.cppImplementation details regarding the Asset representation of a media processing facility
 proc.hppData processing Plugins and Codecs can be treated as a specific Kind of Asset
 procnode.hppInterface to the processing nodes and the render nodes network
 procpatt.cppImplementation details related to "processing pattern" assets
 procpatt.hppDefinition 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.cProbabilistic splay tree implementation
 psplay.hProbabilistic splay tree
 quantiser-basics-test.cppUnit test QuantiserBasics_test
 quantiser.cppImplementation of support functions to create grid-aligned time and timecode values
 quantiser.hppLibrary functions to support the formation of grid-aligned time values
 query-diagnostics.hppDiagnostic helpers to support test related to predicate queries
 query-focus-stack-test.cppUnit test QueryFocusStack_test
 query-focus-stack.hppImplementation facility to work with and navigate nested scopes
 query-focus-test.cppUnit test QueryFocus_test
 query-focus.cpp
 query-focus.hppRepresentation of the current scope when navigating the session model
 query-resolver-test.cppUnit test QueryResolver_test
 query-resolver.cppImplementation of a framework to query and discover elements based on logical rules
 query-resolver.hppFramework and to resolve logical queries
 query-text-test.cppUnit test QueryText_test
 query-text.cppImplementation bits regarding a syntactical standard representation of predicate queries
 query-text.hppA generic syntactical representation for all kinds of queries
 query-util.cppImplementation of helpers for working with predicate queries
 query-util.hppUtilities to support working with predicate queries
 query-utils-test.cppUnit test QueryUtils_test
 query.hppBasic and generic representation of an internal query
 rational-test.cppUnit test Rational_test
 rational.hppRational number support, based on boost::rational
 real-clock.cppImplementation of simplified access to the current wall clock time
 real-clock.hppFront-end for simplified access to the current wall clock time
 rebuildfixturetest.cppUnit test RebuildFixture_test
 recmutex.cRecursive Mutexes
 recmutex.hMutual exclusion locking, header
 record.hppSpecial collection to represent object-like data
 rectangle.cppImplementation of functions to work with rectangular screen ranges
 rectangle.hppHelper functions to work with rectangular screen ranges
 ref-array-impl.hppSome (library-) implementations of the RefArray interface
 ref-array-test.cppUnit test RefArray_test
 ref-array.hppAbstraction interface: array-like access by subscript
 relativelocation.cppLocatingPin (constraint) to attach media objects relative to each other
 relativelocation.hpp
 removefromsettest.cppUnit test RemoveFromSet_test
 render-configurator.cppImplementation functionality to bridge between engine::PlayService and engine::EngineService
 render-configurator.hppStrategy to hold all the detail knowledge necessary to establish a running render CalculationStream
 render-drive.cppImplementation elements of render process planning
 render-drive.hppThe active core within a CalcStream, causing the render mechanism to re-trigger repeatedly
 render-invocation.cppImplementation details regarding the invocation of a single render node
 render-invocation.hppInitiate a single calculation unit within the renderengine
 render-segment-test.cppUnit test RenderSegment_test
 render.cppImplementation of stage:dialog::Render, which is a Dialog to set up a renter process and define output name and format
 render.hppDialog 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
 renderstate.hppBuild and prepare the render state abstraction
 replaceable-item-test.cpp
 replaceable-item.hppAdapter wrapper to treat non-assignable values as if they were assignable
 result-test.cppUnit test Result_test
 result.hppIntermediary value object to represent »either« an operation result or a failure
 root.cpp
 root.hppMObject within the session to represent "the session itself"
 rsvg-convert.cInvoke the rSVG library to render SVG vector graphics with the help of Cairo
 ruler-track.cppImplementation details regarding custom drawing of track overview and time code ticks and markers onto the TimelineCanvas
 ruler-track.hppTimeline presentation helper to organise drawing of the overview rulers
 ruler-widget.cppImplementation details of the time ruler present at top of the timeline display
 ruler-widget.hppThe time overview ruler presented at top of the timeline UI
 run.hppSimple test class runner
 safeclib.cImplementation of error-safe wrappers for some notorious C-Lib functions
 safeclib.hPortable and safe wrappers around some C-Lib functions
 say-hello.hA mock interface to support testing of the interface system
 scheduler-activity-test.cppUnit test SchedulerActivity_test
 scheduler-commutator-test.cppUnit test SchedulerCommutator_test
 scheduler-commutator.hppLayer-2 of the Scheduler: coordination and interaction of activities
 scheduler-diagnostics.hppAn facility to check and monitor the internal workings of the scheduler
 scheduler-frontend.cppScheduler service implementation
 scheduler-frontend.hppScheduler service access point for higher layers
 scheduler-interface-test.cppUnit test SchedulerInterface_test
 scheduler-invocation-test.cppUnit test SchedulerInvocation_test
 scheduler-invocation.hppLayer-1 of the Scheduler: queueing and prioritisation of activities
 scheduler-load-control-test.cppUnit test SchedulerLoadControl_test
 scheduler-service-test.cpp
 scheduler-stress-test.cpp
 scheduler-usage-test.cppUnit test SchedulerService_test
 scheduler.cppImplementation of messaging, dispatch and prioritisation of render activities
 scheduler.hppService for coordination and dispatch of render activities
 scope-cmd.cppActual definition of Steam-Layer command scripts for actions within scope
 scope-locator.hppService to build the notion of a current location within the Sesison model
 scope-path-test.cppUnit test ScopePath_test
 scope-path.cpp
 scope-path.hppAn Object representing a sequence of nested scopes within the Session
 scope-query-test.cppUnit test ScopeQuery_test
 scope-query.hppSpecific queries to explore contents of a scope within the high-level model
 scope.cppImplementation of placement scopes and scope locator
 scope.hpp
 scoped-collection-test.cppUnit test ScopedCollection_test
 scoped-collection.hppManaging a collection of non-copyable polymorphic objects in compact storage
 scoped-holder-test.cppUnit test ScopedHolder_test
 scoped-holder-transfer-test.cppUnit test ScopedHolderTransfer_test
 scoped-holder-transfer.hppA mechanism to take ownership without allowing copy
 scoped-holder.hppSome wrappers for coping with ownership problems
 scoped-ptrvect-test.cppUnit test ScopedPtrVect_test
 scoped-ptrvect.hppManaging lifecycle for a collection of objects
 scriptrunnerfacade.cppSubsystem descriptor and configuration for a controlling and operating Lumiera through bindings to a script language
 scriptrunnerfacade.hppGlobal control interface for script driven operation of Lumiera
 search-path-splitter-test.cppUnit test SearchPathSplitter_test
 searchpath.cppImplementation of helpers to handle directory search paths
 searchpath.hppHelpers to handle directory search paths
 sectionlock.hMutex state handle for locked code sections
 segment.cpp
 segment.hppBuilding block of the backbone of the low-level (render node) model
 segmentation-integration-test.cppIntegration test SegmentationIntegration_test
 segmentation-tool.cppImplementation of builder primitives to create a timeline segmentation
 segmentation-tool.hppVisiting tool to create a viable segmentation of the timeline for rendering
 segmentation.cppImplementation details regarding the Segmentation of the Fixture
 segmentation.hppPart of the Fixture datastructure to manage time segments of constant structure
 sequence-cmd.cppActual definition of Steam-Layer command scripts for actions within a sequence
 sequence.cppImplementation parts of the Sequence entity within the Session model
 sequence.hppStructural building block of the session: a sequence of clips
 sess-manager-impl.cppImplementation of the Session management functions
 sess-manager-impl.hppImplementation facility for session management
 session-cmd.cppActual definition of Steam-Layer command scripts for session-global actions
 session-command-facade.hMajor public Interface to the Session subsystem of Lumiera GUI
 session-command-function-test.cppFunction(integration) test of command dispatch into session thread
 session-command-interface-proxy.cppInterface-Proxy for the steam::control::SessionCommand facade
 session-command-service.cppImplementation of command invocation on the Session interface
 session-command-service.hppA public service offered by the Session, implementing the SessionCommand facade interface
 session-element-query-test.cppUnit test SessionElementQuery_test
 session-element-tracker-test.cppUnit test SessionElementTracker_test
 session-impl.cppImplementation of the global session datastructure
 session-impl.hppSession and SessionServices Implementation classes
 session-interface-modules.hppSelf-contained sub-elements on the Session API
 session-manager-test.cppUnit test SessionManager_test
 session-modify-parts-test.cppUnit test SessionModifyParts_test
 session-query.hppSupporting queries for session contents
 session-service-access-test.cppUnit test SessionServiceAccess_test
 session-service-defaults.hppImplementation level session API: to manage default configured objects
 session-service-explore-scope.hppImplementation level session API: query a scope
 session-service-fetch.hppImplementation level session API: resolve a Placement by hash-ID
 session-service-mock-index.hppImplementation level session API: PlacementIndex mock for tests
 session-service-mutate.hppImplementation level session API: add or remove Session contents
 session-services.cppImplementation of some top-level internal services of the session
 session-services.hppA mechanism for exposing and accessing implementation level services of the session
 session-structure-test.cppUnit test SessionStructure_test
 session.cppActual connection between the Session interface and its Implementation
 session.hppPrimary Interface to the current Session
 Setup.py
 simple-allocator-test.cppUnit test SimpleAllocator_test
 simple-allocator.hppFrontend and marker interface for allocating small objects explicitly
 singleton-subclass-test.cppUnit test SingletonSubclass_test
 singleton-test.cppUnit test Singleton_test
 singleton-testmock-test.cppUnit test SingletonTestMock_test
 size-trait.hppMetaprogramming definitions to deal with dependency on implementation size and layout
 source.cppImplementation of a source media reading render node
 source.hppProcessing node to read media data
 specific-contents-query.hppImplementation facility to query and retrieve session context with filtering conditions
 split-splice-test.cppUnit test SplitSplice_test to verify proper working of the »SplitSplice« algorithm
 split-splice.hpp
 spot-locator.cppImplementation details of a machinery to move the global activity "spot"
 spot-locator.hppNavigating a centre of user activity globally
 state-manager.hppInterface: a component to maintain persistent interface state
 state-map-grouping-storage-test.cppUnit test StateMapGroupingStorage_test
 state-map-grouping-storage.hppImplementation of storage for captured presentation state
 state-recorder.hppImplementation of the PresentationStateManager interface through associative (key-value) store
 state.hppAccess point to an ongoing render's processing state
 stateproxy.cppImplementation details of some stateful operations needed from within the render calculation
 stateproxy.hppAccess point to the state of a frame rendering evaluation
 stave-bracket-widget.cppImplementation of drawing code to indicate the structure of nested tracks
 stave-bracket-widget.hppWidget to group tracks visually in the Timeline presentation
 steam-dispatcher.cppImplementation details of running commands and the builder
 steam-dispatcher.hppDispatch and execute mutation operations on the High-level model
 stream-type-basics-test.cppUnit test StreamTypeBasics_test
 stream-type-lifecycle-test.cppUnit test StreamTypeLifecycle_test
 streamtype.cppImplementation of a stream type framework
 streamtype.hppFramework for classification of media streams
 struct-factory-impl.hppPrivate implementation details of creating various structural assets
 struct-scheme.hppNaming and labelling scheme for structural assets
 struct.cppImplementation functions to support the "structural asset" abstraction
 struct.hppAsset representation of structural elements within the model
 style-scheme.cpp
 style-scheme.hppDefinition of access keys for uniform UI styling
 stypemanager.cppImplementation functions of the stream type system
 stypemanager.hppInterface to the stream type system
 styperegistry.hppThis is part of the implementation of the stream type manager (include)
 sub-id-test.cppUnit test SubID_test
 sub-id.hppExtensible symbolic ID type
 subsys.cppImplementation details of a »subsystem descriptor«
 subsys.hppDescribing dependencies and lifecycle of the application's primary parts
 subsystem-runner-test.cppThe SubsystemRunner_test performs various scenarios regarding start, stop and failure of Subsystems. Its primary purpose is to cover the SubsystemRunner
 subsystem-runner.hppManage execution of the independent Subsystems of the Lumiera application
 suite.cppImplementation of a simple test runner / test suite framework for unit testing
 suite.hppBuilding and running a suite of tests, implemented as test classes
 switchboard-widget.cppImplementation details of the switchboard to control source and overlays of the video viewer
 switchboard-widget.hppWidget to render a switchboard for controlling the video display sources and overlays
 symbol-hashtable-test.cppUnit test SymbolHashtable_test
 symbol-impl.cppCollection of helpers for working with the lib::Symbol
 symbol-table.hppRegistry table for automatically interned strings
 symbol-test.cppUnit test Symbol_test
 symbol.hppMarker types to indicate a literal string and a Symbol
 sync-barrier-performance-test.cppAssess the performance characteristics of lib::SyncBarrier Helpers and setup for the SyncBarrierPerformance_test
 sync-barrier-test.cppUnit test SyncBarrier_test
 sync-barrier.hppA N-fold synchronisation latch using yield-wait until fulfilment
 sync-classlock-test.cppUnit test SyncClasslock_test
 sync-classlock.hppA 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.cppUnit test SyncLocking_test
 sync-timedwait-test.cppUnit test SyncTimedwait_test
 sync-waiting-test.cppUnit test SyncWaiting_test
 sync.hppObject Monitor based synchronisation
 tangible.cppCommon base implementation of all tangible and connected interface elements
 tangible.hppAbstraction: a tangible element of the User Interface
 test-coll.hppSome bits of unit test helper code to fabricate collections with test data
 test-configloader.cC unit test to cover a config system draft implementation
 test-control.hppNon-modal dialog window to trigger diagnostics and self test routines
 test-dummy-commands.cppImplementation of dummy command operations for unit tests
 test-dummy-commands.hppSome dummy command functions used for building unit test cases
 test-dummy-mobject.hppA hierarchy of simple dummy-Media-Objects for easy unit testing
 test-element-access.hppUnit test helper for access to UI elements without actually running an UI
 test-errorstate.cC 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.cppUnit test TestHelper_test
 test-helper-variadic-test.cppUnit test TestHelperVariadic_test
 test-helper.cppDefinition of some widely used test helper functions
 test-helper.hppA collection of frequently used helper functions to support unit testing
 test-interfaces.cC unit test to cover the basics of our interface and plugin-loading system
 test-llist.cC unit test to cover a linked list library implementation
 test-locking.cC 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.cC unit test to cover generation of Lumiera Uniform Identifier hashes
 test-mutation-target.hppDiagnostic helper for unit tests regarding mutation of custom data
 test-nexus.cppImplementation of a fake UI backbone for testing
 test-nexus.hppA fake UI backbone for investigations and unit testing
 test-option-test.cppUnit test TestOption_test
 test-psplay.cC unit test to cover a probabilistic splay tree library implementation
 test-safeclib.cC unit test to cover size checked C operations
 test-scope-invalid.hppUnit test helper to generate deliberately wrong placement scopes
 test-scopes.cppImplementation of nested test scopes to cover the placement index
 test-scopes.hppUnit test helper to generate a system of nested test scopes
 test-target-obj.hppDummy 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.cC unit test to cover the basic low-level time handling operations
 test.hHelpers and support macros for defining test executables in C
 testasset.cppImplementation of a mocked Asset for unit tests
 testasset.hppA mock asset to support unit testing
 testclip.cppImplementation of a stubbed clip object to support unit testing
 testclip.hppA stub implementation of the Clip interface for unit testing
 testclipasset.hppA placeholder Clip asset to support unit testing
 testdummy.hppUnittest helper code: test dummy objects to track instances
 testframe-test.cppUnit test TestFrame_test
 testframe.cppImplementation of fake data frames to support unit testing
 testframe.hppUnit test helper to generate fake test data frames
 testoption.cppImplementation of commandline parsing for the unittest test-suite
 testoption.hppCommandline options for our unittest test-suite executable
 testroot.hppSetup of a faked session root for unit testing
 testrunner.cppLumiera unit test suite A simple test runner application
 testsession1.hppDummy session content prepared for unit test
 teststreamtypes.hppUnit test helper to create fake streamtype information
 thread-wrapper-autonomous-test.cppUnit test ThreadWrapperAutonomous_test
 thread-wrapper-join-test.cppUnit test ThreadWrapperJoin_test
 thread-wrapper-lifecycle-test.cppUnit test ThreadWrapperLifecycle_test
 thread-wrapper-self-recognition-test.cppUnit test ThreadWrapperSelfRecognitionTest_test
 thread-wrapper-test.cppUnit test ThreadWrapper_test
 thread.cpp
 thread.hppConvenience front-end to simplify and codify basic thread handling
 tick-service.hppA timer service invoking a given callback periodically
 time-basics-test.cppUnit test TimeBasics_test
 time-control-test.cppUnit test TimeControl_test
 time-formats-test.cppUnit test TimeFormats_test
 time-grid-basics-test.cppUnit test TimeGridBasics_test
 time-grid.cppImplementation of access to time-quantised reference scales
 time-grid.hppTo establish a reference scale for quantised time values
 time-mutation-test.cppUnit test TimeMutation_test
 time-parsing-test.cppUnit test TimeParsing_test
 time-quantisation-test.cppUnit test TimeQuantisation_test
 time-value-test.cppUnit test TimeValue_test
 time.cppLumiera time handling core implementation unit
 time.hCommon functions for handling of time values
 timecode-widget.cppWidget for timecode display and input
 timecode-widget.hppWidget for timecode display and input
 timecode.cppImplementation parts of the timecode handling library
 timecode.hppTimecode 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.cppImplementation details of timeline operation management and control
 timeline-controller.hppController to supervise operation of timeline display in the UI
 timeline-gui.cppImplementation details a delegating anchor proxy for a TimelineWidget
 timeline-gui.hppAnchor point and placeholder for the UI representation of a Timeline from the session
 timeline-layout.cppImplementation details of global timeline layout management
 timeline-layout.hppA core service of the timeline UI to ensure consistent display and layout of all components within the timeline
 timeline-panel.cppImplementation of the dockable panel to hold the main timeline display
 timeline-panel.hppA dockable container to hold a notebook of timeline displays
 timeline-sequence-handling-test.cppUnit test TimelineSequenceHandling_test
 timeline-state.cppImplementation of presentation state for the first draft of the timeline display
 timeline-state.hppPresentation state for the first draft of the timeline display
 timeline-widget-empty.hppEmpty placeholder to be rendered when the UI starts without session
 timeline-widget.cppImplementation details of Lumiera's timeline display widget
 timeline-widget.hppThis file defines the core component of the Lumiera GUI
 timeline-zoom-scale.cppWidget to control timeline zoom scale
 timeline-zoom-scale.hppWidget to control timeline zoom scale
 timeline.cppImplementation functions of the Timeline entity within the Session model
 timeline.hppTop level structural element within the session
 timequant.hppSupport library to represent grid-aligned time specifications This is part of Lumiera's time and time code handling framework
 timevalue.hppFamily of time value like entities and their relationships
 timing-constraints-test.cppUnit test TimingConstraints_test
 timings-test.cpp
 timings.cppImplementation of a data tuple for timing specification
 timings.hppHow to define a timing specification or constraint
 tmpbuf.cImplementation of temporary buffers with round-robin usage pattern
 tmpbuf.hRound robin temporary buffers
 ToolCCache.py
 ToolDistCC.py
 toolfactory.cppImplementation of factory functions for the tools used within the Builder
 toolfactory.hppFactory to create the tools for the build process
 track-body.cppImplementation details regarding display management of the track body area within the timeline display canvas
 track-body.hppThis helper class serves to manage the layout and display of the horizontally extended space of a "track" within the timeline
 track-head-widget.cppImplementation details regarding display of the track heads within the timeline UI
 track-head-widget.hppWidget to represent a track head with placement parameters, within the timeline header pane
 track-presenter.hppPresentation control element to model and manage a track within the timeline UI
 track-profile.hppAbstraction to build the layout for the track spaces within timeline display
 tracking-heap-block-provider-test.cppUnit test TrackingHeapBlockProvider_test
 tracking-heap-block-provider.cppImplementation details of a mock engine::BufferProvider for unit testing
 tracking-heap-block-provider.hppDummy implementation of the BufferProvider interface to support writing unit tests
 trait-special.hppRarely used specialisations of otherwise heavily used generic code
 trait.hppHelpers for type detection, type rewriting and metaprogramming
 transition-widget.cppImplementation details of transition UI control
 transition-widget.hppUI representation of a transition to blend several media elements
 tree-diff-application.hppConcrete implementation to apply structural changes to hierarchical data structures
 tree-diff-traits.hppDefinitions and Properties to guide automated tree mutator binding
 tree-diff.cppImplementation of diff application to unspecific private data structures
 tree-diff.hppA token language to represent structural changes in a tree like hierarchical data structure
 tree-mutator-attribute-binding.hppSpecial binding implementation for TreeMutator, allowing to map tree diff operations onto native object attributes
 tree-mutator-binding-test.cppUnit test TreeMutatorBinding_test
 tree-mutator-collection-binding.hppSpecial binding implementation for lib::diff::TreeMutator, allowing to map tree diff operations onto a STL collection of native implementation objects
 tree-mutator-diffmutable-binding.hppSpecial 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.hppSpecial binding implementation for TreeMutator, allowing to map tree diff operations onto an »External Tree Description«
 tree-mutator-listener-binding.hppSpecial supplement for TreeMutator, to attach listeners for notification on specific changes, especially structural ones
 tree-mutator-noop-binding.hppSpecial binding implementation for TreeMutator, allowing to accept and ignore any tree diff without tangible effect
 tree-mutator-test.cppUnit test TreeMutator_test
 tree-mutator.hppCustomisable intermediary to abstract generic tree mutation operations
 tuple-diagnostics.hppExtension to typelist-diagnostics.hpp, allowing to dump the contents of a Tuple datatype
 tuple-helper-test.cppInterplay of typelists, type tuples and std::tuple
 tuple-helper.hppMetaprogramming with tuples-of-types and the std::tuple record
 tuple-record-init-test.cppUnit test TupleRecordInit_test
 tuple-record-init.hppSpecialised adapter to consume a record of GenNode entries to build a tuple
 type-demangling-test.cppUnit test TypeDemangling_test
 type-display-test.cppUnit test TypeDisplay_test
 type-handler.hppHelper holding a pair of type-build-up and destruction functors
 typed-allocation-manager-test.cppUnit test TypedAllocationManager_test
 typed-allocation-manager.hppAbstract foundation for building custom allocation managers
 typed-counter-test.cppStress test to verify type-based contexts
 typed-counter.hppCreating series of type-based contexts
 typed-family-member-id-test.cppUnit test to verify generation of a Member ID within a type based family of objects
 typed-id-test.cppUnit test TypedID_test
 typed-id.hppFrontend for a registration service to associate object identities, symbolic identifiers and types
 typed-lookup.cppImplementation backend for a registration service to associate IDs, types and object instances
 typelist-diagnostics.hppSupport for writing metaprogramming unit-tests dealing with typelists and flags
 typelist-manip-test.cpp
 typelist-manip.hppMetaprogramming: Helpers for manipulating lists-of-types
 typelist-test.cppUnit test TypeList_test
 typelist-util-test.cppUnit test TypeListUtil_test
 typelist-util.hppMetaprogramming: simple helpers for working with lists-of-types
 typelist.hppA template metaprogramming technique for manipulating collections of types
 typeseq-manip-test.cppVerify the proper working of simple type sequence manipulations
 typeseq-util.hppSome basic facilities for manipulating type sequences
 ui-bus.cppImplementation of the UI backbone service for messaging
 ui-bus.hppUnder construction: the top level UI controller
 ui-coord-resolver-test.cppUnit test UICoordResolver_test
 ui-coord-resolver.cppImplementation details of resolving a UICoord path against the actual UI topology
 ui-coord-resolver.hppEvaluation of UI coordinates against a concrete window topology
 ui-coord-test.cppUnit test UICoord_test
 ui-coord.hppA topological addressing scheme to designate structural locations within the UI
 ui-dispatcher.hppAllow dispatch of self-contained code blocks (lambdas) into the main UI event thread
 ui-location-solver-test.cppUnit test UILocationSolver_test
 ui-location-solver.hppA solver to match incomplete coordinate specifications against the actual UI topology
 ui-manager.cppImplementation of global concerns regarding a coherent UI and global state
 ui-manager.hppManager for global user interface concerns, framework integration and global state
 ui-protocol.cppStorage for key constants and basic definitions used for interfacing with the GUI
 ui-protocol.hppHard wired key constants and basic definitions for communication with the GUI
 ui-state.cppImplementation of a manager to establish and store global persistent UI state
 ui-state.hppEstablish and handle persistent interface state
 ui-style.cppImplementation of global concerns regarding a coherent UI and global state
 ui-style.hppService for global theming and style related concerns
 unique-malloc-owner-test.cppUnit test UniqueMallocOwner_test
 unique-malloc-owner.hppHelper to deal with C-MALLOCed memory automatically
 unknown.cppImplementation functions regarding a marker asset for unknown media
 unknown.hppMarker Asset to indicate an unknown media source
 util-coll.hppSome small helpers and convenience shortcuts to ease working with collections and sequences (given by iterator)
 util-collection-test.cppUnit test UtilCollection_test
 util-floordiv-test.cppUnit test UtilFloordiv_test
 util-floorwrap-test.cppUnit test UtilFloorwrap_test
 util-foreach-test.cppUnit test UtilForeach_test
 util-foreach.hppPerform operations "for each element" of a collection
 util-parse-bool-test.cppUnit test UtilParseBool_test
 util-quant.hppUtilities for quantisation (grid alignment) and comparisons
 util-sanitised-identifier-test.cppUnit test UtilSanitizedIdentifier_test
 util-tuple-test.cppUnit test UtilTuple_test
 util-tuple.hpp
 util.cppImplementation of widely used helper functions
 meta/util.hppSimple and lightweight helpers for metaprogramming and type detection
 util.hppTiny 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.hppType re-binding helper template for custom containers and adapters
 variadic-argument-picker-test.cppVerify metaprogramming manipulation on a variadic parameter pack
 variadic-helper.hppMetaprogramming with type sequences based on variadic template parameters
 variant-o.hppThis file defines a simple alternative to boost::variant
 variant-test.cppUnit test Variant_test
 variant.hppA typesafe union record to carry embedded values of unrelated type
 vcall.hThis 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.cppUnit test VectorTransfer_test
 verb-function-dispatch-test.cppDemonstrate the concept of a verb language based on double dispatch
 verb-token.hppBuilding blocks for a simple DSL using double dispatch to a handler function
 verb-visitor-dispatch-test.cppDemonstrate the extended concept of a verb language based on double dispatch
 verb-visitor.hppA specific double dispatch variation for function invocation
 vgsuppression.cDummy executable to generate valgrind suppressions
 video-display-widget.cppImplementation of video display, embedded into the UI
 video-display-widget.hppWidget to create a video display embedded into the UI
 view-hook-test.cppUnit test ViewHook_test
 view-hook.hppAllow widgets to connect to a common shared presentation context
 view-locator.cppImplementation details of a machinery to allocate UI global component views
 view-locator.hppAccess and allocation of UI component views
 view-spec-dsl-test.cppUnit test ViewSpecDSL_test
 view-spec-dsl.hppA framework for configuration of view access and allocation patterns
 viewer-panel.cppImplementation of a dockable panel to hold the video viewers
 viewer-panel.hppDefinition of a dockable panel to hold the video viewers
 viewer.cppImplementation functions to represent a viewer or viewer attachment point
 viewer.hppStructural element corresponding to a viewer in the GUI
 virtual-copy-support-test.cppUnit test VirtualCopySupport_test
 virtual-copy-support.hppHelper for building "virtual copy" operations
 visitingtool-concept.cppWhile 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.cppUnit test VisitingToolExtended_test
 visitingtool-test.cppUnit test VisitingTool_test
 visitor-dispatcher.hppHelper for a trampoline table based implementation of the visitor pattern
 visitor-policies.hppPolicies usable for configuring the lib::visitor::Tool for different kinds of error handling
 visitor.hppA library implementation of the Visitor Pattern tailored specifically to Lumiera's needs within the Steam Layer
 w-link-test.cppUnit test WLink_test
 w-link.hppA smart link to an GTK widget with automatic disconnection
 widget.hppCommon Abstraction of all UIBus connected widget elements
 window-locator.cppImplementation details of management and access to all top level windows and docking panels
 window-locator.hppManager for all top level application windows
 wiringrequest.hppSymbolic representation of a goal for node wiring
 wish.cpp
 wish.hpp
 wizard.cppImplementation of the global help controller to show the user manual
 wizard.hppGlobal help controller
 work-force-test.cppUnit test WorkForce_test
 work-force.cppImplementation of render worker coordination
 work-force.hppA pool of workers for multithreaded rendering
 work-site-trail.cppImplementation aspects regarding a history of visited work sites
 work-site-trail.hppHistory of work sites visited by the user in recent past
 work-site.cppImplementation aspects of the WorkSite abstraction
 work-site.hppRepresent a place "in" the interface where the user is about to do something
 workspace-window.cppImplementation of base functionality for workspace windows
 workspace-window.hppThis file contains the definition of the main workspace window parent, which is the toplevel parent of the whole workspace
 wrapper.hppLibrary implementation: smart-pointer variations, wrappers and managing holders
 wrapperptr.hppWrapper to treat several flavours of smart-pointers uniformly
 xvdisplayer.cppImplementation of video output via XVideo
 xvdisplayer.hppImplementation of video output via XVideo
 zombie-check-test.cppUnit test Singleton_test
 zombie-check.hppDetector to set off alarm when (re)using deceased objects
 zoom-metric.hppImplementation building block to get the DisplayMetric as defined through a ZoomWindow
 zoom-window-test.cppUnit test ZoomWindow_test The timeline uses the abstraction of an »Zoom Window« to define the scrolling and temporal scaling behaviour uniformly
 zoom-window.cppCommon implementation details related to zoom handling and transformation into screen coordinates
 zoom-window.hppAbstraction: the current zoom- and navigation state of a view, possibly in multiple dimensions