Lumiera  0.pre.03
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
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
 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.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.hppThis file contains the definition of a helper class for the main workspace window object, which registers and handles user actions
 advice.cppImplementation the AdviceSystem, to support the advice collaboration
 advice.hppExpecting Advice and giving Advice: a cross-cutting collaboration of loosely coupled participants
 allocation-cluster.hppMemory management for the low-level model (render nodes network)
 alsa.hInterfacing to ALSA sound output
 applicable-builder-target-types.hppDeclaration of all kinds of MObjects to be treated by some "Builder tool"
 appstate.hppRegistering and managing primary application-global services
 argument-tuple-accept.hppMixin-templates providing arbitrary function call operators and argument binding functions
 asset-diagnostics.hppSmall helper and diagnostic functions related to Asset and AssetManager
 asset.hppProc-Layer Interface: Assets
 assetmanager.hppProc-Layer Interface: Asset Lookup and Organisation
 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
 buildertool.hppVisiting-tool mechanism configured specifically for the Builder
 buildinstruct.hppHelper classes used by asset::ProcPatt to represent the processing information
 bus-controller.cppImplementation of the UI backbone service for messaging
 bus-controller.hppThe service actually operating the UI-Bus
 bus-term.hppAttachment point to the UI-Bus
 channel-descriptor.hppRepresentation of the Media type of a data channel used within the engine
 clip-track.hppThis file contains the definition of timeline track objects which contain clips
 gui/model/clip.hppThis file defines a Proxy Clip object to base the GUI implementation on
 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-impl-clone-builder.hppHelper for creating an implementation clone, based on the visitor pattern
 command-impl.hppTop level of the command implementation
 command-invocation.hppSome additional helpers and convenience shortcuts to ease command invocation
 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-registry.hppManaging command definitions and the storage of individual command objects
 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.cppImplementation of the command frontend
 command.hppProc-Layer command frontend
 condition.cCondition variables
 condition.hCondition variables, header
 config-interface.hExternal interface to the lumiera configuration system
 config-lookup.cImplementation of the lookup of configuration keys
 config-lookup.hLookup of configuration keys
 config-resolver.hppDefinition of the concrete frontend for rule based configuration within the session
 config-rules.hppInterface for accessing rule based configuration
 config.hInterface for a lumiera configuration system (draft)
 configflags.hppUnder some circumstances it is necessary to assemble functionality out of elementary building blocks
 configitem.cImplementation: create a configitem from a single line of the config file
 configitem.hHierarchy of configuration items
 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
 core-service.hppDedicated service node within the UI-Bus to handle command invocation and presentation state
 defs-manager-impl.hppImplementation of the core defaults-management operations
 defs-registry.hppA piece of implementation code factored out into a separate header (include)
 del-stash.hppCollecting and finally triggering deleter functions
 depend.hppSingleton services and Dependency Injection
 diagnostic-buffer-provider.hppA facility for writing unit-tests targeting the BufferProvider interface
 diagnostic-context.hppFacility for collecting diagnostic context information explicitly
 diagnostic-output-slot.hppAn facility for writing unit-tests against the OutputSlot interface
 diff-language.hppFundamental definitions for a representation of changes
 diff-mutable.hppAbstraction or descriptor interface for a data structure exposing the ability for mutation by receiving diff messages
 diff.cppDiff handling framework support code
 digxel.hppA self-contained numeric element for building structured numeric displays
 display-facade.hExperimental Interface, allowing the Dummy-Player to access the video display widget in the GUI
 display-interface-proxy.hppThis is an implementation fragment, intended to be included into common/interfaceproxy.cpp
 display-service.hppA public service provided by the GUI, implementing the lumiera::Display facade interface
 displayer.hppThe Displayer serves as base of all video display implementations
 duck-detector.hppMetaprogramming helpers to check for specific properties of a type in question
 dummy-image-generator.hppGenerator for test dummy video frames to simulate playback of rendered output
 dummy-play-connection.hppDummy and test setup of playback and rendering, omitting most of the Lumiera engine
 dummy-player-interface-proxy.hppThis is an implementation fragment, intended to be included into common/interfaceproxy.cpp
 dummy-player-service.hppA public service provided by the Proc-Layer, implementing a dummy/mockup playback process
 dummy-tick.hppA timer service invoking a given callback periodically
 element-tracker.hppTracking instances automatically on creation and disposal
 element.hppGeneric building block in the Lumiera GUI model
 engine-diagnostics.hppAn facility to check and monitor engine operations
 engine-service-mock.hppPlaceholder implementation of the render engine for test and diagnostics
 engine-service.hppAccess point for the (core) calculation service of the render engine
 entry-id.hppBare symbolic and hash ID used for accounting of asset like entries
 error-exception.cppImplementation of C++-style error handling
 error-state.cImplementation of C-style error handling in Lumiera
 error.hLumiera error handling (C interface)
 error.hppLumiera error handling (C++ interface)
 event-log.hppSupport for verifying the occurrence of events from unit tests
 facade.hppTop level entrance point and facade for the Proc-Layer
 fake-configrules.hppMock/Test/Debugging Implementation of the config rules system
 file.hFile management
 filedescriptor.hFile descriptors are the underlying working horse in accessing files
 filedescriptorregistry.hRegistry for used file descriptors
 filehandle.hFilehandles manage the underlying POSIX filehandle for a file descriptor
 filehandlecache.hCaching and management of filehandles
 fileheader.hCommon header format to identify various kinds of files
 fixture-change-detector.hppWork out the part of the Fixture changed by a build process
 format-cout.hppAutomatically use custom string conversion in C++ stream output
 format-obj.cppSome implementation helpers for simple object display
 format-obj.hppSimple functions to represent objects, for debugging and diagnostics
 format-string.cppImplementation for printf-style formatting, based on boost::format
 format-string.hppFront-end for printf-style string template interpolation
 format-util.hppCollection of small helpers and convenience shortcuts for diagnostics & formatting
 function-closure-test.cppTesting a combination of tr1::function objects and metaprogramming
 function-closure.hppPartial function application and building a complete function closure
 function-erasure.hppGeneric holder for functor objects, concealing the concrete function type
 function.hppMetaprogramming tools for transforming functor types
 functor-util.hppCollection of small helpers and utilities related to function objects
 gdkdisplayer.hppDisplay video via GDK
 gen-node.cppGeneric node element (implementation parts)
 gen-node.hppGeneric building block for tree shaped (meta)data structures
 generator-combinations.hppMetaprogramming facilities to generate combination cases
 generator.hppHelpers for working with lib::meta::Types (i.e
 genfunc.hppGeneric function to build identification schemes
 gtk-base.hppA set of basic GTK includes
 gtk-lumiera.hppThe main application object
 guifacade.hppInterface for the GUI loader and for accessing the GUI interface from the lower layers of Lumiera
 guinotification-facade.hMajor public Interface of the Lumiera GUI
 guistart.cppStart up the Lumiera GTK GUI when loading it as dynamic module
 handle.hppA generic opaque handle to an implementation entity, including lifecycle management
 handling-pattern.hppPre-defined command execution skeletons
 handling-patterns.hppA hard wired collection of predefined command handling patterns
 hash-fnv.hFowler-Noll-Vo Hashes
 hash-indexed.hppA template for generating hash based ID tags carrying compile-time type info
 hash-standard.hppHelper to use a single extension point for specialised hash functions
 hash-value.hHash value types and utilities
 hierarchy-orientation-indicator.hppHelper to support navigating a tree structure
 index-table.hppGeneric lookup table for a sequence of unique values
 index.hppImplementation datastructure for use by the Advice system
 instancehandle.hppA handle template for automatically dealing with interface and plugin registration and deregistration
 interaction-state-manager.cppCommon base implementation for UI state tracking components
 interaction-state-manager.hppAbstraction: a component to watch, maintain and guide UI state
 interface-facade-link.hppOpening, accessing and closing the service access through a facade interface
 interface.cImplementation: handling of interfaces (extension points)
 interface.hLumiera interface macros and structures
 interfaceproxy.hppFacade Interfaces Lifecycle
 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)
 invocation-trail.hppA command in preparation of being issued from the UI
 iter-adapter-ptr-deref.hppExtension adapter for Lumiera Forward Iterators to dereference any pointer values automatically
 iter-adapter-stl.hppPreconfigured adapters for some STL container standard usage situations
 iter-adapter.hppHelper template(s) for creating lumiera forward iterators
 iter-cursor.hppAn iterator with the ability to switch direction
 iter-explorer.hppHelper template(s) for establishing various evaluation strategies for hierarchical data structures
 iter-source.hppExtension module to build an opaque data source, accessible as Lumiera Forward Iterator
 iter-stack.hppConveniently iterable stack and queue containers
 iter-type-binding.hppType re-binding helper template for IterAdapter and friends
 itertools.hppHelpers for working with iterators based on the pipeline model
 job-planning.hppThe "mechanics" of discovering and planning frame calculation jobs
 job-ticket.cppImplementation details of preparing and performing job invocations
 job.cppImplementation of render job invocation
 job.hDefinition of a render job
 lifecycle-advisor.hppImplementation facility providing an operation skeleton of session lifecycle
 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.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.hppImplementing the Placement mechanics
 logging.hThis header is for including and configuring NoBug
 luid.hLumiera unique object identifier
 luidgen.cGenerate a fixed LUID to be hard-wired into source code
 maybe.hppSupport for representation of optional values
 media.hppMedia data is a specific kind of Asset
 memento-tie.hppA special binding used by Proc-Layer commands for capturing UNDO state information
 mmap.hMMap objects cover a memory mapped range in a file
 mmapcache.hLumiera's Mmapcache stores a MRU cache of all established mmaped memory regions which are currently not in use
 mmapings.hManage the mmap objects of a file
 mobject-ref.cppImplementation part of the MObjectRef facility
 mobject-ref.hppExternal MObject/Placement reference
 mock-elm.hppA generic interface element instrumented for unit testing
 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
 mrucache.hMost recent used cache Elements (addressed by a LList node) are either checked in the cache and thereby subject of aging or checked out under control of the user
 multifact.hppFramework for building a configurable factory, to generate families of related objects
 mutation.cppA collection of concrete forms of time mutation
 mutation.hppModifying time and timecode values
 mutex.cMutual exclusion locking
 mutex.hMutual exclusion locking, header
 nexus.hppCore hub and routing table of the UI-Bus
 nobug-init.hppTrigger the basic NoBug initialisation by placing a static variable
 nobug-resource-handle-context.hppThread-local stack of NoBug resource handles
 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
 notification-interface-proxy.hppThis is an implementation fragment, intended to be included into common/interfaceproxy.cpp
 notification-service.hppA public service provided by the GUI, implementing the gui::GuiNotification facade interface
 null-value.hppSingleton-style holder for NIL or default values
 observable-list.hppThis file contains the definition of the observable list class
 opaque-holder.hppHelper allowing type erasure while holding the actual object inline
 output-designation.cppImplementation details of OutputDesignation and OutputMapping
 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.hppTranslating and wiring output designations
 output-slot-connection.hppInterface for concrete output implementations to talk to the OutputSlot frontend
 output-slot.hppAn (abstract) capability to send media data to an external output
 p.hppCustomised refcounting smart pointer
 panel-bar.hppCustom container widget to allow placing toolbar buttons into the active docking header area of GDL docking panels
 panel-manager.hppManagement of dockable panels
 parent-track.hppThis file contains the definition of ParentTrack, a class which represents a base functionality for tracks and sequences which are also track parents
 placeholder-command.hppGenerate fake commands with stub operations and the ability to verify invocation
 placement-index-query-resolver.hppImplementing resolution of "discover contents"-queries based on PlacementIndex
 placement-index.cppImplementation of core session storage structure
 placement-index.hppCore of the session implementation datastructure
 placement-ref.hppA generic reference mechanism for Placements, as added to the current session
 placement.hppPlacements are at the very core of all editing operations, because they act as handles to access the media objects to be manipulated
 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-process.hppOrganisational unit of an ongoing render- or playback process
 play-service.hppPrimary service of the Player subsystem: Starting and controlling render/playback
 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.hppA mechanism to allow for opaque polymorphic value objects
 ppmpl.hPreprocessor metaprogramming library
 presentation-state-manager.cppImplementation details of persistent presentation state organisation
 presentation-state-manager.hppInterface: a component to maintain persistent interface state
 priqueue.hSimple priority queue implementation based on a binary heap
 proc-dispatcher.hppDispatch and execute mutation operations on the High-level model
 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
 project.hppThis file contains the definition of Project, a class which stores project data, and wraps proc layer data
 psplay.hProbabilistic splay trees A splay trees is self-optimizing (in contrast to self-balancing) datastructure
 query-text.hppA generic syntactical representation for all kinds of queries
 query.hppBasic and generic representation of an internal query
 real-clock.hppFront-end for simplified access to the current wall clock time
 reccondition.cCondition variables
 reccondition.hCondition variables, header
 recmutex.cRecursive Mutexes
 recmutex.hMutual exclusion locking, header
 record.hppSpecial collection to represent object-like data
 ref-array-impl.hppSome (library-) implementations of the RefArray interface
 render-configurator.hppStrategy holding all the detail knowledge necessary to establish a running render CalculationStream
 render-invocation.hppInitiate a single calculation unit within the renderengine
 render.hppDefinition of the render output dialog
 result.hppIntermediary value object to represent the result of an operation
 run.hppSimple test class runner
 rwlock.cRead/write locks
 rwlock.hRead/write locks, header
 safeclib.hPortable and safe wrappers around some clib functions and some tools
 scheduler-diagnostics.hppAn facility to check and monitor the internal workings of the scheduler
 scope-path.hppAn Object representing a sequence of nested scopes within the Session
 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.hppManaging a collection of noncopyable polymorphic objects in compact storage
 scoped-holder.hppSome wrappers for coping with ownership problems
 scoped-ptrvect.hppManaging lifecycle for a collection of objects
 sess-manager-impl.cppImplementation of the Session management functions
 session-facade.cppService for session-facade
 session-facade.hppService for session-facade
 session-impl.hppSession and SessionServices Implementation classes
 session-interface-modules.hppSelf-contained sub-elements on the Session API
 session-query.hppSupporting queries for session contents
 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.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.cppActual connection between the Session interface and its Implementation
 session.hppPrimary Interface to the current Session
 simple-allocator.hppFrontend and marker interface for allocating small objects explicitly
 singleton-ref.hppHelper for singleton-kind access without managing object creation and lifecycle
 slist.hIntrusive cyclic single linked list
 state-map-grouping-storage.hppImplementation of storage for captured presentation state
 state-recorder.hppImplementation of the PresentationStateManager interface through associative (key-value) store
 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.hppStructural parts of the Session (e.g
 styperegistry.hppThis is part of the implementation of the stream type manager (include)
 sub-id.hppExtensible symbolic ID type
 subsys.hppDescribing dependencies and lifecycle of the application's primary parts
 suite.hppBuilding and running a suite of tests, implemented as test classes
 symbol.hppWIP placeholder definition for a planned Symbol datatype
 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.cppThis compilation unit holds the static attribute struct for initialising pthread's recursive mutex
 sync.hppObject Monitor based synchronisation
 tangible-update-test.cppThis test is a concept study regarding a generic structure of UI elements
 tangible.cppCommon base implementation of all tangible and connected interface elements
 tangible.hppAbstraction: a tangible element of the User Interface
 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-helper.cppDefinition of some widely used test helper functions
 test-helper.hppA collection of frequently used helper functions to support unit testing
 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.hHelpers and support macros for defining test executables in C
 thread-local.hppHelpers for working with thread local data
 threadpool-init.hppAutomatically bring up the Threading management and Threadpool in the backend
 tick-service.hppA timer service invoking a given callback periodically
 time-grid.hppEstablishing a reference scale for quantised time values
 time.cppLumiera time handling core implementation unit
 time.hCommon functions for handling of time values
 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-entity.hppAny UI element that can be placed on the timeline
 timeline-ibeam-tool.hppA tool to select ranges in the timeline
 timeline-layout-helper.cppThis file contains the definition of the layout helper class
 timeline-panel.hppThis file contains the definition of the timeline panel
 timeline-widget.hppThis file defines the core component of the Lumiera GUI
 timeline.hppTop level structural element within the session
 timevalue.hppFamily of time value like entities and their relationships
 timings.hppHow to define a timing specification or constraint
 tmpbuf.hRound robin temporary buffers
 track.hppThis file contains the definition of Track, a class which represents a track, and wraps proc layer data
 tracking-heap-block-provider.hppDummy implementation of the BufferProvider interface to support writing unit tests
 trait.hppHelpers for type detection, type rewriting and metaprogramming
 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-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.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.hppMetaprogramming with tuples-of-types and the std::tuple record
 tuple-record-init.hppSpecialised adapter to consume a record of GenNode entries to build a tuple
 type-handler.hppHelper holding a pair of type-build-up and destruction functors
 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-id.hppFrontend for a registration service to associate object identities, symbolic identifiers and types
 typelist-diagnostics.hppSupport for writing metaprogramming unit-tests dealing with typelists and flags
 typelist-manip.hppMetaprogramming: Helpers for manipulating lists-of-types
 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.hppUnder construction: the top level UI controller
 unique-malloc-owner.hppHelper to deal with C-MALLOCed memory automatically
 util-coll.hppSome small helpers and convenience shortcuts to ease working with collections and sequences (given by iterator)
 util-foreach.hppPerform operations "for each element" of a collection
 variant-o.hppThis file defines a simple alternative to boost::variant
 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
 verb-token.hppBuilding blocks for a simple DSL using double dispatch to a handler function
 viewer-panel.hppThis file contains the definition of the viewer panel
 viewer.hppStructural element corresponding to a viewer in the GUI
 virtual-copy-support.hppHelper for building "virtual copy" operations
 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
 widget.hppCommon Abstraction of all UIBus connected widget elements
 window-manager.hppManager for all application windows and resources
 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
 xvdisplayer.hppImplementation of video output via XVideo