Lumiera  0.pre.03
File List
Here is a list of all files with brief descriptions:
 abstract-tangible-test.cppVerify the common base shared by all interface elements of relevance
 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
 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)
 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 Proc-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
 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.hppProc-Layer Interface: Assets
 assetmanager.cppImplementation of Asset lookup and organisation functions
 assetmanager.hppProc-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
 backend.cLumiera Backend: implementation of global initialisation and services
 backend.hLumiera Backend: global initialisation and definitions
 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
 proc/mobject/session/binding.cppImplementation details of the Binding MObject to tie a sequence into a timeline or virtual clip
 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.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-tool-test.cppUnit test BuilderTool_test
 builderfacade.cppImplementation of top-level access to builder functionality
 builderfacade.hppProc-Layer Facade: access to the Builder
 buildertool.hppVisiting-tool mechanism configured specifically for the Builder
 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-plan-continuation.cppImplementation elements of render process planning
 calc-plan-continuation.hppA specialised render job to care for the planning of the calculation process itself
 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
 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.cppImplementation details of clip presentation management
 clip-presenter.hppPresentation control element to model and manage a clip within the timeline UI
 clip-track.cppPreliminary UI-model: Implementation of timeline track model object
 clip-track.hppPreliminary UI-model: Definition of timeline track objects which contain clips
 clip-widget.cppImplementation details of clip display within the Lumiera UI
 clip-widget.hppThis widget provides the concrete rendering of a clip-like entity
 gui/model/clip.cppPreliminary UI-model: implementation of a Clip object as placeholder to base the GUI implementation on
 proc/asset/clip.cppClip Asset implementation
 proc/mobject/session/clip.cppImplementation details regarding a media clip as integrated into the edit / session model
 gui/model/clip.hppPreliminary UI-model: a Proxy Clip object to base the GUI implementation on
 proc/asset/clip.hppDefinition of Asset representation for a media clip
 proc/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 Proc-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 ProcDispatcher
 command-def.hppActually defining a command and binding it to execution parameters
 command-dispatch.hppInterface to abstract the ProcDispatcher'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 Proc-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.hppImplementation building block of ProcDispatcher 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.hppProc-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
 common.hppBasic set of definitions and includes commonly used together
 compoundmedia.hppDefinition of an Asset to represent a clustering or compound of several media
 compoundmediatest.cppUnit test CompoundMedia_test
 condition.cCondition variables
 condition.hCondition variables, header
 config-facade.hThe lumiera::Config wrapper class addresses two issues
 config-interface.cA public interface to a (planned) global configuration system
 config-interface.hExternal interface to the lumiera configuration system
 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 Proc-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-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)
 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 "Proc-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
 gui/model/diagnostics.hppService for diagnostics
 lib/time/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-test.cppUnit test DiffTreeApplication_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.cppImplementation parts of job generation within an ongoing render process
 dispatcher.hppService abstraction within the render engine for generating render jobs
 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-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
 draw-strategy.hppStrategy interface for drawing timeline entities
 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-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-job.cppImplementation of a dummy render job for unit tests
 dummy-job.hppUnit test helper to generate dummy render jobs
 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-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 Proc-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
 asset/effect.hppDefinition of an Asset representation for any kind of effect or media processor
 element-access-test.cppUnit test ElementAccess_test
 element-access.hppInterface to discover and access raw UI elements in a cross cutting way
 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.hAccess point to configuration of engine parameters
 engine-diagnostics.hppAn facility to check and monitor engine operations
 engine-interface-test.cppUnit test EngineInterface_test
 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.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
 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
 facade.cppImplementation of subsystem lifecycle behaviour for the core parts of Proc-Layer
 fake-configrules.cppImplementation of a fake query resolution service based on preconfigured answers
 fake-configrules.hppMock/Test/Debugging Implementation of the config rules system
 file-handling.cImplementation of file management functions
 file.hFile management
 filedescriptor.cImplementation of a file descriptor management framework
 filedescriptor.hFile descriptors are the underlying working horse in accessing files
 filedescriptorregistry.cImplementation of a registry to manage used filedescriptors
 filedescriptorregistry.hRegistry for used file descriptors
 filehandle.cImplementation of filehandle representation
 filehandle.hFilehandles manage the underlying POSIX filehandle for a file descriptor
 filehandlecache.cImplementation of caching for filehandle representation data
 filehandlecache.hCaching and management of filehandles
 fileheader.cImplementation of a common header format for working data files created by the lumiera backend
 fileheader.hCommon header format to identify various kinds of files
 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.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
 frame-coord.hppTuple data type to address distinct frames within the render engine calculations
 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
 functor-util-test.cppUnit test FunctorUtil_test
 functor-util.hppCollection of small helpers and utilities related to function objects
 gdkdisplayer.cppDysfunctional implementation code, formerly used to create a video display based on GDK
 gdkdisplayer.hppDisplay video via GDK
 gen-node-basic-test.cppUnit test GenNodeBasic_test
 gen-node-location-query.hppImplementation of the gui::interact::LocationQuery interface to work on a GenNode tree
 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.hppA data generator media object
 generator.hppHelpers for working with lib::meta::Types (i.e
 generic-id-function-test.cppUnit test GenericIdFunction_test
 generic-record-representation-test.cppUnit test GenericRecordRepresentation_test
 genfunc.cppImplementation of generic functions to build identification schemes
 genfunc.hppGeneric functions to build identification schemes
 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
 group-track.cppPreliminary UI-model: Implementation for the group track timeline objects
 group-track.hppPreliminary UI-model: Definition of group track timeline objects
 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.cppImplementation of the track header pane within the timeline UI
 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
 hierarchy-orientation-indicator-test.cppUnit test HierarchyOrientationIndicator_test
 hierarchy-orientation-indicator.hppHelper to support navigating a tree structure
 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
 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 several usage scenarios and extensions built on top of the lib::IterExplorer template
 iter-explorer.hppHelper template(s) for establishing various evaluation strategies for hierarchical data structures
 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
 iter-tree-explorer-test.cppThe IterTreeExplorer_test covers and demonstrates a generic mechanism to expand and evaluate tree like structures
 iter-tree-explorer.hppBuilding tree expanding and backtracking evaluations within hierarchical scopes
 iterable-classification-test.cppUnit test IterableClassification_test
 itertools-test.cppUnit test IterTools_test
 itertools.hppHelpers for working with iterators based on the pipeline model
 job-hash-test.cppUnit test JobHash_test
 job-planning.hppThe "mechanics" of discovering and planning 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-widget.cppImplementation details of the UI building block to display an ID label
 label-widget.hppWidget to render an ID label with associated icon
 label.hppA marker or reference point in the Session
 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
 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 ProcDispatcher 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
 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
 maybe-value-test.cppUnit test MaybeValue_test
 maybe.hppSupport for representation of optional values
 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.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 Proc-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 Proc-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.hppA function 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
 mmap.cImplementation of management for memory mapped file regions
 mmap.hMMap objects cover a memory mapped range in a file
 mmapcache.cImplementation of caching for currently unused memory mapped file regions
 mmapcache.hLumiera's Mmapcache stores a MRU cache of all established mmaped memory regions which are currently not in use
 mmapings.cImplementation of organisational data of memory mapped file regions
 mmapings.hManage the mmap objects of a file
 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.hppCore factory to generate media objects for use in the Session model
 mock-elm.hppA generic interface element instrumented for unit testing
 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
 mpool.cImplementation of pooling memory allocation functions for constant sized objects
 mpool.hPooled memory allocator for constant sized objects Memory Pools are implemented as clusters of fixed sized elements
 mrucache.cImplementation of a caching by most recent use
 mrucache.hMost recent used cache
 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-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
 notification-hub.hppController to receive and handle notification messages for the user
 notification-interface-proxy.cppInterface-Proxy for the gui::GuiNotification facade
 notification-service.cppImplementation of notifications and updates within the GUI
 notification-service.hppA public service provided by the GUI, implementing the gui::GuiNotification facade interface
 null-value-test.cppUnit test NullValue_test
 null-value.hppSingleton-style holder for NIL or default values
 observable-list.hppThis file contains the definition of the observable list class
 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
 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
 parent-track.cppPreliminary UI-model: Implementation of ParentTrack
 parent-track.hppPreliminary UI-model: Definition of ParentTrack, a class which represents a base functionality for tracks and sequences which are also track parents
 patchbay-widget.cppImplementation details of the patchbay, allowing to tweak parameters of a fork's placement
 patchbay-widget.hppWidget to control the placement parameters of a fork 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.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
 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
 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
 priqueue.cSimple "text book" implementation of a priority queue, based on a binary heap
 priqueue.hSimple priority queue implementation based on a binary heap
 proc-dispatcher.cppImplementation details of running commands and the builder
 proc-dispatcher.hppDispatch and execute mutation operations on the High-level model
 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
 project.cppPreliminary UI-model: Implementation of Project, a class which stores project data, and wraps proc layer data
 project.hppPreliminary UI-model: Definition of Project, a class which stores project data, and wraps proc layer data
 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.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
 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
 reccondition.cCondition variables
 reccondition.hCondition variables, header
 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
 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-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 gui: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.hpp(Planned) access point to the render engine as service
 renderstate.hppBuild and prepare the render state abstraction
 replaceable-item.hppAdapter wrapper to treat non-assignable values as if they were assignable
 resourcecollector.cImplementation of a global service to manage scarce system resources
 resourcecollector.hA global manager for scarce system resources
 result.hppIntermediary value object to represent the result of an operation
 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-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
 rwlock.cRead/write locks
 rwlock.hRead/write locks, header
 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-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
 scope-cmd.cppActual definition of Proc-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.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
 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.hppBuilding block of the backbone of the low-level (render node) model
 segmentation-datastructure-test.cppUnit test SegmentationDatastructure_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.hppPart of the Fixture datastructure to manage time segments of constant structure
 sequence-cmd.cppActual definition of Proc-Layer command scripts for actions within a sequence
 gui/model/sequence.cppPreliminary UI-model: implementation of an editable sequence
 proc/asset/sequence.cppImplementation parts of the Sequence entity within the Session model
 gui/model/sequence.hppPreliminary UI-model: representation of an editable sequence
 proc/asset/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 Proc-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 proc::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-facade.cppService for session-facade
 session-facade.hppService for session-facade
 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-mapping-test.cppThis test is a concept study how to organise the proxy model in the Lumiera GUI
 session-structure-test.cppUnit test SessionStructure_test
 session.cppActual connection between the Session interface and its Implementation
 session.hppPrimary Interface to the current Session
 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
 slist.hIntrusive cyclic single linked list
 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
 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
 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.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.cppUnit test SubsystemRunner_test
 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-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-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.cppThis compilation unit holds the static attribute struct for initialising pthread's recursive mutex
 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-event-log-test.cppUnit test TestEventLog_test
 test-filedescriptors.cC unit test to cover filedescriptor management
 test-filehandles.cC unit test to cover management for filehandles and the filehandle cache
 test-fileheader.cC unit test to verify file identification functions
 test-filemmap.cC unit test to cover memory mapping of file contents
 test-gui-test.cppUnit test TestGui_test
 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-mpool.cC unit test to cover a memory pool custom allocator
 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-priqueue.cC unit test to cover a priority queue library implementation
 test-psplay.cC unit test to cover a probabilistic splay tree library implementation
 test-resourcecollector.cC unit test to cover management of low-level resources for the backend
 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-slist.cC unit test to cover a single linked list library implementation
 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-threadpool.cC unit test to cover our threadpool implementation
 test-threads.cC unit test to cover thread handling helpers Especially, we rely on a specific setup for threads, which allows to manage worker threads in a threadpool
 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 object
 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-local-test.cppUnit test ThreadLocal_test
 thread-local.hppHelpers for working with thread local data
 thread-wrapper-join-test.cppUnit test ThreadWrapperJoin_test
 thread-wrapper-test.cppUnit test ThreadWrapper_test
 thread-wrapper.hppConvenience front-end for basic thread handling needs
 threadpool-init.cppImplementation of automatic initialisation of the low-level thread handling framework
 threadpool-init.hppAutomatically bring up the threading management and threadpool in the backend
 threadpool.cImplementation of a threadpool
 threads.cImplementation of Lumiera's low-level thread handling framework
 threads.hLumiera low-level thread handling framework
 tick-service.hppA timer service invoking a given callback periodically
 time-anchor.hppRepresentation of a continuation point for planning the render process
 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-arrow-tool.hppThis file contains the definition of the arrow tool class
 timeline-body.hppThis file contains the definition of timeline body widget
 timeline-clip-track.hppTimeline track objects which contain clips
 timeline-clip.hppRepresentation of a clip on the timeline
 timeline-controller.cppImplementation details of timeline operation management and control
 timeline-controller.hppController to supervise operation of timeline display in the UI
 timeline-entity.cppImplementation of a generic element to be placed onto the timeline
 timeline-entity.hppAny UI element that can be placed on the timeline
 timeline-group-track.hppPreliminary implementation of a group track within the timeline display
 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-header-container.hppA container to hold the header area of the timeline display
 timeline-header-widget.hppWidget to generate the timeline header
 timeline-ibeam-tool.hppA tool to select ranges in the timeline
 timeline-layout-helper.cppPreliminary implementation of Timeline presentation, layout helper
 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-obsolete.hppThis file contains the definition of the timeline panel
 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-ruler.cppThe ruler at the top of the timeline display to represent the time axis
 timeline-ruler.hppThe ruler at the top of the timeline display to represent the time axis
 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-tool.cppTools and working modes for selections in the timeline
 timeline-tool.hppTools and working modes for selections in the timeline
 timeline-track.cppA group track in the first draft version of the timeline display
 timeline-track.hppA group track in the first draft version of the timeline display
 timeline-view-window.cppImplementation of the timeline window, which holds the main timeline display
 timeline-view-window.hppHelper to manage the timeline window, which holds the main timeline display
 timeline-widget-empty.hppEmpty placeholder to be rendered when the UI starts without session
 timeline/timeline-widget.cppImplementation details of Lumiera's timeline display widget
 timeline/timeline-widget.hppThis file defines the core component of the Lumiera GUI
 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.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
 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 control patchbay within Lumiera's timeline UI
 track-presenter.cppImplementation details of track presentation management
 track-presenter.hppPresentation control element to model and manage a track within the timeline UI
 track.cppPreliminary UI-model: Implementation for the track timeline objects
 track.hppPreliminary UI-model: Definition of Track, a class which represents a track, and wraps proc layer data
 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 TreeMutator, allowing to map tree diff operations onto a STL collection of native implementation objects
 tree-mutator-gen-node-binding.hppSpecial binding implementation for TreeMutator, allowing to map tree diff operations onto an »External Tree Description«
 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
 tree.hppA tree implementation class in STL style
 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.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.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.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
 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-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 Proc 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
 wizard.cppImplementation of the global help controller to show the user manual
 wizard.hppGlobal help controller
 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