From 02c58097076610167fe32ebd8c138d10e8afc4f8 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Thu, 15 Nov 2018 23:59:23 +0100 Subject: [PATCH] Global-Layer-Renaming: adjust namespace qualification --- doc/design/application/SubsystemLifecycle.txt | 4 +- doc/technical/code/gtk/index.txt | 2 +- doc/technical/code/gtk/startup.txt | 14 ++-- doc/technical/stage/CodePolicy.txt | 2 +- doc/technical/stage/GuiConnect.txt | 2 +- research/gtk-canvas-main.cpp | 2 +- src/common/display-interface-proxy.cpp | 2 +- src/common/guifacade.cpp | 2 +- src/common/instancehandle.hpp | 2 +- src/common/notification-interface-proxy.cpp | 10 +-- src/common/query/defs-manager-impl.hpp | 4 +- src/include/display-facade.h | 4 +- src/include/display-handles.h | 2 +- src/include/gui-notification-facade.h | 2 +- src/include/play-facade.hpp | 18 ++--- src/include/session-command-facade.h | 8 +- src/include/ui-protocol.hpp | 2 +- src/lib/call-queue.hpp | 2 +- src/lib/diff/mutation-message.hpp | 2 +- src/lib/format-obj.cpp | 6 +- src/lib/handle.hpp | 2 +- src/lib/idi/entry-id.hpp | 2 +- src/lib/iter-explorer.hpp | 2 +- src/lib/maybe.hpp | 2 +- src/lib/meta/configflags.hpp | 4 +- src/lib/path-array.hpp | 2 +- src/lib/priqueue.h | 2 +- src/lib/replaceable-item.hpp | 2 +- src/lib/result.hpp | 2 +- src/lib/scoped-ptrvect.hpp | 2 +- src/lib/test/microbenchmark.hpp | 2 +- src/lib/wrapperptr.hpp | 2 +- src/lumiera/main.cpp | 12 +-- src/stage/ctrl/bus-term.hpp | 4 +- src/stage/ctrl/core-service.hpp | 6 +- src/stage/ctrl/state-recorder.hpp | 4 +- src/stage/dialog/test-control.hpp | 14 ++-- src/stage/display-service.hpp | 2 +- src/stage/gtk-base.hpp | 4 +- src/stage/gtk-lumiera.cpp | 12 +-- src/stage/guifacade.hpp | 6 +- src/stage/id-scheme.hpp | 4 +- src/stage/interact/interaction-director.cpp | 10 +-- src/stage/interact/ui-coord-resolver.hpp | 4 +- src/stage/interact/view-locator.cpp | 6 +- src/stage/interact/view-locator.hpp | 2 +- src/stage/interact/view-spec-dsl.hpp | 2 +- src/stage/interact/wizard.hpp | 2 +- src/stage/model/controller.hpp | 2 +- src/stage/model/element-access.hpp | 2 +- src/stage/model/flash-deco.hpp | 2 +- src/stage/model/widget.hpp | 2 +- src/stage/notification-service.cpp | 4 +- src/stage/notification-service.hpp | 8 +- src/stage/panel/timeline-panel-obsolete.cpp | 14 ++-- src/stage/panel/timeline-panel-obsolete.hpp | 6 +- src/stage/panel/timeline-panel.hpp | 4 +- src/stage/setting/asset-controller.hpp | 4 +- src/stage/style-scheme.cpp | 2 +- src/stage/timeline/clip-presenter.hpp | 2 +- src/stage/timeline/timeline-controller.cpp | 2 +- src/stage/timeline/timeline-gui.cpp | 6 +- src/stage/timeline/timeline-gui.hpp | 4 +- src/stage/timeline/timeline-widget.hpp | 4 +- src/stage/timeline/track-presenter.hpp | 2 +- src/stage/ui-bus.cpp | 12 +-- src/stage/ui-bus.hpp | 4 +- src/stage/widget/bin-widget.hpp | 2 +- src/stage/widget/button-bar.cpp | 2 +- src/stage/widget/button-bar.hpp | 2 +- src/stage/widget/error-log-display.hpp | 2 +- src/stage/widget/menu-button.cpp | 2 +- src/stage/widget/menu-button.hpp | 2 +- src/stage/widget/mini-button.hpp | 2 +- src/stage/widget/panel-bar.cpp | 2 +- src/stage/widget/panel-bar.hpp | 2 +- src/stage/widget/timecode-widget.cpp | 2 +- src/stage/widget/timecode-widget.hpp | 2 +- src/stage/widget/timeline-widget.cpp | 4 +- src/stage/widget/timeline-widget.hpp | 6 +- src/stage/widget/timeline/timeline-body.cpp | 2 +- src/stage/widget/timeline/timeline-body.hpp | 4 +- .../timeline/timeline-header-container.cpp | 2 +- .../timeline/timeline-header-container.hpp | 6 +- .../timeline/timeline-header-widget.cpp | 2 +- .../timeline/timeline-layout-helper.cpp | 2 +- .../timeline/timeline-layout-helper.hpp | 2 +- src/stage/widget/timeline/timeline-ruler.cpp | 2 +- src/stage/widget/timeline/timeline-ruler.hpp | 4 +- src/stage/widget/timeline/timeline-tool.cpp | 4 +- src/stage/widget/timeline/timeline-tool.hpp | 2 +- src/stage/widget/video-display-widget.cpp | 2 +- src/stage/widget/video-display-widget.hpp | 2 +- src/steam/asset.hpp | 10 +-- src/steam/asset/media.hpp | 6 +- src/steam/asset/meta/error-log.hpp | 6 +- src/steam/asset/struct-factory-impl.hpp | 16 ++-- src/steam/asset/struct-scheme.hpp | 2 +- src/steam/asset/struct.cpp | 2 +- src/steam/assetmanager.hpp | 2 +- src/steam/cmd/meta-cmd.cpp | 20 ++--- src/steam/config-resolver.cpp | 18 ++--- src/steam/config-resolver.hpp | 12 +-- .../control/command-instance-manager.hpp | 2 +- src/steam/control/command-setup.cpp | 2 +- src/steam/control/looper.hpp | 2 +- src/steam/control/proc-dispatcher.cpp | 2 +- src/steam/control/proc-dispatcher.hpp | 2 +- .../session-command-interface-proxy.cpp | 6 +- src/steam/control/session-command-service.hpp | 2 +- src/steam/control/stypemanager.cpp | 2 +- src/steam/control/stypemanager.hpp | 2 +- src/steam/engine/calc-plan-continuation.hpp | 4 +- src/steam/engine/engine-diagnostics.hpp | 2 +- src/steam/engine/engine-service-mock.hpp | 4 +- src/steam/engine/engine-service.hpp | 8 +- src/steam/engine/job-planning.hpp | 2 +- src/steam/engine/job-ticket.cpp | 4 +- src/steam/engine/job-ticket.hpp | 2 +- src/steam/engine/nodewiring-config.hpp | 2 +- src/steam/engine/nodewiring-def.hpp | 2 +- src/steam/engine/stateproxy.hpp | 2 +- src/steam/engine/time-anchor.hpp | 2 +- .../engine/worker/dummy-image-generator.hpp | 4 +- src/steam/engine/worker/dummy-tick.hpp | 4 +- src/steam/engine/worker/tick-service.hpp | 4 +- src/steam/facade.cpp | 4 +- src/steam/mobject/output-designation.cpp | 2 +- .../session/dummy-session-connection.cpp | 22 ++--- .../session/dummy-session-connection.hpp | 6 +- src/steam/mobject/session/placement-index.hpp | 4 +- .../session/query/fake-configrules.hpp | 8 +- src/steam/mobject/session/scope-path.hpp | 2 +- src/steam/play/dummy-play-connection.hpp | 2 +- .../play/dummy-player-interface-proxy.cpp | 2 +- src/steam/play/dummy-player-service.cpp | 2 +- src/steam/play/dummy-player-service.hpp | 8 +- src/steam/play/output-director.cpp | 2 +- src/steam/play/output-slot-connection.hpp | 4 +- src/steam/play/output-slot.hpp | 4 +- src/steam/play/play-controller.cpp | 4 +- src/steam/play/play-controller.hpp | 2 +- src/steam/play/play-process.hpp | 4 +- src/steam/play/render-configurator.hpp | 4 +- src/steam/play/sound/jack-output.hpp | 2 +- src/steam/play/timings.cpp | 2 +- src/steam/play/timings.hpp | 2 +- src/steam/state.hpp | 2 +- src/steam/streamtype.hpp | 2 +- src/vault/engine/engine-config.cpp | 2 +- src/vault/engine/job.cpp | 2 +- src/vault/engine/job.h | 2 +- src/vault/media-access-facade.hpp | 6 +- src/vault/thread-wrapper.hpp | 2 +- tests/basics/call-queue-test.cpp | 4 +- tests/basics/diagnostic-context-test.cpp | 4 +- tests/basics/time/time-control-test.cpp | 2 +- tests/basics/time/time-formats-test.cpp | 2 +- tests/basics/time/time-mutation-test.cpp | 2 +- tests/basics/time/time-parsing-test.cpp | 2 +- tests/basics/time/time-quantisation-test.cpp | 2 +- tests/basics/typed-counter-test.cpp | 2 +- .../application/subsystem-runner-test.cpp | 2 +- tests/core/steam/asset/create-asset-test.cpp | 4 +- .../steam/asset/dependent-assets-test.cpp | 4 +- tests/core/steam/asset/entry-id-test.cpp | 16 ++-- .../steam/asset/identity-of-assets-test.cpp | 4 +- tests/core/steam/asset/make-clip-test.cpp | 4 +- .../steam/asset/ordering-of-assets-test.cpp | 4 +- tests/core/steam/asset/typed-id-test.cpp | 6 +- .../control/command-instance-manager-test.cpp | 2 +- .../core/steam/control/command-setup-test.cpp | 4 +- .../steam/control/dispatcher-looper-test.cpp | 2 +- .../control/session-command-function-test.cpp | 10 +-- .../engine/buffer-provider-protocol-test.cpp | 2 +- .../steam/engine/engine-interface-test.cpp | 4 +- .../mobject/builder/builder-tool-test.cpp | 4 +- .../steam/mobject/mobject-interface-test.cpp | 4 +- tests/core/steam/mobject/mobject-ref-test.cpp | 4 +- .../mobject/placement-hierarchy-test.cpp | 4 +- .../session/defs-manager-impl-test.cpp | 2 +- tests/core/steam/mobject/session/testclip.cpp | 2 +- .../steam/play/diagnostic-output-slot.hpp | 12 +-- .../steam/play/dummy-play-connection-test.cpp | 6 +- .../steam/play/output-slot-protocol-test.cpp | 6 +- .../steam/play/timing-constraints-test.cpp | 6 +- .../vault/engine/scheduler-interface-test.cpp | 2 +- tests/core/vault/media-access-mock.cpp | 2 +- tests/library/iter-explorer-test.cpp | 2 +- tests/library/meta/config-flags-test.cpp | 4 +- .../meta/iterable-classification-test.cpp | 4 +- tests/library/meta/tuple-record-init-test.cpp | 2 +- tests/library/meta/type-display-test.cpp | 6 +- tests/library/replaceable-item-test.cpp | 2 +- tests/stage/abstract-tangible-test.cpp | 40 +++++----- tests/stage/bus-term-test.cpp | 80 +++++++++---------- tests/stage/gen-node-location-query.hpp | 2 +- tests/stage/interact/view-spec-dsl-test.cpp | 10 +-- tests/stage/model/element-access-test.cpp | 8 +- .../stage/session-structure-mapping-test.cpp | 4 +- tests/stage/test/mock-elm.hpp | 14 ++-- tests/stage/test/placeholder-command.hpp | 4 +- tests/stage/test/test-nexus.cpp | 20 ++--- tests/vault/sync-classlock-test.cpp | 2 +- tests/vault/sync-locking-test.cpp | 2 +- tests/vault/sync-waiting-test.cpp | 2 +- tests/vault/thread-local-test.cpp | 4 +- tests/vault/thread-wrapper-join-test.cpp | 2 +- .../thread-wrapper-self-recognition-test.cpp | 2 +- tests/vault/thread-wrapper-test.cpp | 2 +- 210 files changed, 499 insertions(+), 499 deletions(-) diff --git a/doc/design/application/SubsystemLifecycle.txt b/doc/design/application/SubsystemLifecycle.txt index 283b769fc..bff850b03 100644 --- a/doc/design/application/SubsystemLifecycle.txt +++ b/doc/design/application/SubsystemLifecycle.txt @@ -48,7 +48,7 @@ for the code referred in the following discussion. additionally the services of +lumiera::AppState+ (+common/appstate.hpp+) - AppState represents the state as relevant for the "application realm", i.e. it performs global initialisation and shutdown. See especially +AppState::init()+ -- see +backend/enginefacade.hpp|cpp+ as an (unimplemented) façade skeleton. +backend::EngineFacade::getDescriptor()+ +- see +vault/enginefacade.hpp|cpp+ as an (unimplemented) façade skeleton. +vault::EngineFacade::getDescriptor()+ yields the subsystem interface - the GuiFacade is somewhat special, because we want to load the GUI from a shared library. This façade is basically completed and working, but it currently @@ -61,7 +61,7 @@ for the code referred in the following discussion. separation interfaces are considered part of the public Lumiera API, thus the headers go into +src/include/**+ * include/guinotification.h (C/C++ combined header) defines an C++ interface (abstract class) and a CLI interface. - * embedded into the interface is a factory, i.e. by gui::GuiNotification::facade() you get an instance... + * embedded into the interface is a factory, i.e. by stage::GuiNotification::facade() you get an instance... * which actually is a proxy and routes any call through the instance of the accompanying CLI interface which is defined within the interface/plugin system * this in turn forwards to the implementation class in diff --git a/doc/technical/code/gtk/index.txt b/doc/technical/code/gtk/index.txt index 53ff6f09b..49cce177e 100644 --- a/doc/technical/code/gtk/index.txt +++ b/doc/technical/code/gtk/index.txt @@ -72,7 +72,7 @@ tend to get into our way of working. For this reason Consequently, none of the services offered by `Gtk::Application` is of much use for us. After reading the source code, we came to the conclusion that it is perfectly valid to sidestep all those aspects of GTK, and just perform those small number of toolkit initialisation steps -- previously invoked -by `Gtk::Main` -- directly from our application code. Basically Lumiera's `gui::ctrl::UiManager` +by `Gtk::Main` -- directly from our application code. Basically Lumiera's `stage::ctrl::UiManager` replaces `Gtk::Main`, invokes `gtk_init` and enters the blocking event loop by calling `gtk_main`. diff --git a/doc/technical/code/gtk/startup.txt b/doc/technical/code/gtk/startup.txt index 713be5d33..59119c6f4 100644 --- a/doc/technical/code/gtk/startup.txt +++ b/doc/technical/code/gtk/startup.txt @@ -53,15 +53,15 @@ to the plain-C type `GApplication`.] Thus, we leave out the third stage and deal application global aspects through means appropriate to our specific purpose. - our link:{ldoc}/design/architecture/Subsystems.html[Subsystem runner] boots the UI subsystem - (`gui::GuiFacade`), which in turn loads the UI-plug-in ('target/modules/gtk_gui.lum'). -- within this plug-in, the class `gui::GtkLumiera` governs the complete UI lifecycle. -- this class holds a member `gui::ctl::UiManager` -- which is our ``UI main object'' and mimics + (`stage::GuiFacade`), which in turn loads the UI-plug-in ('target/modules/gtk_gui.lum'). +- within this plug-in, the class `stage::GtkLumiera` governs the complete UI lifecycle. +- this class holds a member `stage::ctl::UiManager` -- which is our ``UI main object'' and mimics the design of the late `Gtk::Main`. -- we inherit from our own `gui::ctrl::ApplicationBase` class, to ensure invocation of all the +- we inherit from our own `stage::ctrl::ApplicationBase` class, to ensure invocation of all the initialisation and clean-up functions required by GTK -- we instantiate a class `gui::ctrl::GlobalCtx` to hold and provide all global services used +- we instantiate a class `stage::ctrl::GlobalCtx` to hold and provide all global services used throughout the UI layer, including population of the menu and global actions -- within the global context, there is also `gui::ctrl::WindowLocator`, to keep track of all +- within the global context, there is also `stage::ctrl::WindowLocator`, to keep track of all top-level application windows, and to support direct navigation to relevant entities within the UI, based on _abstracted UI-coordinates_. - finally, `GtkLumiera` invokes the functions @@ -138,7 +138,7 @@ Shutdown -------- The GTK main loop terminates after invocation of `gtk_main_quit()` (or in case of serious internal errors). Typically, this function is somehow bound to a widget interaction, like clicking on the ``close'' button. -In Lumiera, this concern is managed by the `gui::ctrl::WindowLocator`, which keeps track of all top-level +In Lumiera, this concern is managed by the `stage::ctrl::WindowLocator`, which keeps track of all top-level windows and terminates the UI when the last one is closed. Moreover, the UI can deliberately be closed by sending an event over the `GuiNotification::triggerGuiShutdown(message)' call. diff --git a/doc/technical/stage/CodePolicy.txt b/doc/technical/stage/CodePolicy.txt index 4627509c2..b3fdc1371 100644 --- a/doc/technical/stage/CodePolicy.txt +++ b/doc/technical/stage/CodePolicy.txt @@ -30,7 +30,7 @@ UI-Model In short: _there is no dedicated UI-Model._ Stateful working data goes directly into the widgets. However, some widgets or controllers are special, insofar they correspond to and reflect some entities within the _Session model._ These special -entities must be implemented as subclasses of `gui::model::Tangible`. These are +entities must be implemented as subclasses of `stage::model::Tangible`. These are always connected to the UI-Bus, and they are populated and mutated by receiving diff messages pushed up from the Steam-Layer. diff --git a/doc/technical/stage/GuiConnect.txt b/doc/technical/stage/GuiConnect.txt index 9f0263c29..c7a9d6221 100644 --- a/doc/technical/stage/GuiConnect.txt +++ b/doc/technical/stage/GuiConnect.txt @@ -63,7 +63,7 @@ dispatches any invocation into the UI thread. Within the UI-Layer, we do not rely on a central ``shadow model'', rather, the backbone of the UI is a communication structure, the *UI-Bus*. Data within the GUI is kept very local, close to the presentation widgets. In fact, we -identify a selection of _really important_ UI elements, which we call ``the tangible elements'' (`gui::model::Tangible`). +identify a selection of _really important_ UI elements, which we call ``the tangible elements'' (`stage::model::Tangible`). Each of those primary elements within the UI _is connected to the UI-Bus,_ and can be addressed by its ID, and it happens to correspond and reflect an entity within the session model, there denoted by the same ID. The core can thus send a message towards the corresponding tangible UI element, without any knowledge as to how and where this diff --git a/research/gtk-canvas-main.cpp b/research/gtk-canvas-main.cpp index f8770dbc4..411659728 100644 --- a/research/gtk-canvas-main.cpp +++ b/research/gtk-canvas-main.cpp @@ -25,7 +25,7 @@ ** This demo application was extracted in 10/2018 to preserve ** [exploration experiments](\ref demo::CanvasDemoPanel), carried ** out in 2016 to decide upon the technology to support Lumiera's - ** gui::timeline::TimelineWidget. + ** stage::timeline::TimelineWidget. */ diff --git a/src/common/display-interface-proxy.cpp b/src/common/display-interface-proxy.cpp index ac8cbdc93..24a660205 100644 --- a/src/common/display-interface-proxy.cpp +++ b/src/common/display-interface-proxy.cpp @@ -54,7 +54,7 @@ namespace facade { - /* ==================== gui::Display ====================================== */ + /* ==================== stage::Display ====================================== */ using Interface = LUMIERA_INTERFACE_INAME(lumieraorg_Display, 0); using Facade = lumiera::Display; diff --git a/src/common/guifacade.cpp b/src/common/guifacade.cpp index 0600e8386..1b11bac13 100644 --- a/src/common/guifacade.cpp +++ b/src/common/guifacade.cpp @@ -25,7 +25,7 @@ ** Implementation of the GUI loader. Code generated from this ** translation unit is linked into the core application, where it implements ** the [Subsystem descriptor](\ref subsys.hpp) for the _UI Subsystem._ When main() - ** activates and starts this subsystem, an instance of gui::GuiRunner will be + ** activates and starts this subsystem, an instance of stage::GuiRunner will be ** created, which causes the Lumiera UI plug-in to be loaded and a new thread ** to be spawned, which launches the UI and performs the event loop. */ diff --git a/src/common/instancehandle.hpp b/src/common/instancehandle.hpp index c61be7d3a..d72f4585b 100644 --- a/src/common/instancehandle.hpp +++ b/src/common/instancehandle.hpp @@ -29,7 +29,7 @@ ** out of scope. Additionally, access via an (existing) interface proxy ** may be enabled and disabled alongside with the loading and unloading. ** - ** @see gui::GuiFacade usage example + ** @see stage::GuiFacade usage example ** @see interface.h ** @see interfaceproxy.hpp (more explanations) ** @see session-command-interface-proxy.cpp (Proxy implementation example) diff --git a/src/common/notification-interface-proxy.cpp b/src/common/notification-interface-proxy.cpp index 24a0c3508..1c9cef9dc 100644 --- a/src/common/notification-interface-proxy.cpp +++ b/src/common/notification-interface-proxy.cpp @@ -23,8 +23,8 @@ /** @file notification-interface-proxy.cpp - ** Interface-Proxy for the gui::GuiNotification facade. - ** The purpose is to define a proxy implementation of gui::GuiNotification, in order to + ** Interface-Proxy for the stage::GuiNotification facade. + ** The purpose is to define a proxy implementation of stage::GuiNotification, in order to ** redirect any calls through the associated C Language Interface "lumieraorg_GuiNotification" ** ** @see gui-notification-facade.hpp @@ -41,7 +41,7 @@ namespace stage { } namespace lumiera { namespace facade { - using gui::ID; + using stage::ID; using lib::diff::GenNode; using lib::diff::MutationMessage; @@ -50,7 +50,7 @@ namespace facade { /* ==================== SessionCommand =================================== */ using Interface = LUMIERA_INTERFACE_INAME(lumieraorg_GuiNotification, 0); - using Facade = gui::GuiNotification; + using Facade = stage::GuiNotification; using IHandle = InstanceHandle; @@ -59,7 +59,7 @@ namespace facade { class Proxy : public Binding { - using Level = gui::NotifyLevel; + using Level = stage::NotifyLevel; //----Proxy-Implementation-of-GuiNotification-------- diff --git a/src/common/query/defs-manager-impl.hpp b/src/common/query/defs-manager-impl.hpp index 4771d12c8..a4e76d7f4 100644 --- a/src/common/query/defs-manager-impl.hpp +++ b/src/common/query/defs-manager-impl.hpp @@ -32,7 +32,7 @@ ** core MObject types, alongside with the definition of the generic config-query-resolver. ** ** @see config-resolver.cpp definition of the explicit specialisations for the session - ** @see proc::ConfigResolver + ** @see steam::ConfigResolver ** */ @@ -51,7 +51,7 @@ using util::_Fmt; -using proc::ConfigResolver; +using steam::ConfigResolver; using lumiera::query::QueryHandler; ///////TODO preliminary interface defined in config-rules.hpp using lumiera::query::LERR_(CAPABILITY_QUERY); diff --git a/src/include/display-facade.h b/src/include/display-facade.h index 3cfd6b28e..e0e0af5ec 100644 --- a/src/include/display-facade.h +++ b/src/include/display-facade.h @@ -34,7 +34,7 @@ ** registers with the OutputManager in the core. ** ** @see [corresponding implementation](\ref display-service.hpp) - ** @see gui::GuiFacade + ** @see stage::GuiFacade ** @see dummy-player-facade.h ** */ @@ -80,7 +80,7 @@ namespace lumiera { * considerably if we get at devising the real player. * * @see dummy-player-facade.hpp - * @see gui::PlaybackController + * @see stage::PlaybackController * */ class Display diff --git a/src/include/display-handles.h b/src/include/display-handles.h index 61446a26b..4e72a6bdd 100644 --- a/src/include/display-handles.h +++ b/src/include/display-handles.h @@ -24,7 +24,7 @@ ** Opaque handles and similar typedefs used to communicate via the ** lumiera::Display and lumiera::DummyPlayer facade interfaces. ** - ** @see gui::DisplayService + ** @see stage::DisplayService ** */ diff --git a/src/include/gui-notification-facade.h b/src/include/gui-notification-facade.h index 15dab0d35..f58a81af1 100644 --- a/src/include/gui-notification-facade.h +++ b/src/include/gui-notification-facade.h @@ -31,7 +31,7 @@ ** to happen in the UI in response to the reception of these messages. ** ** @see notification-service.hpp implementation - ** @see gui::GuiFacade + ** @see stage::GuiFacade ** @see main.cpp */ diff --git a/src/include/play-facade.hpp b/src/include/play-facade.hpp index 886e9ecab..9960abf81 100644 --- a/src/include/play-facade.hpp +++ b/src/include/play-facade.hpp @@ -105,7 +105,7 @@ namespace lumiera { * @see player-service.cpp implementation */ class Controller - : public lib::Handle + : public lib::Handle { public: void play(bool); ///< play/pause toggle @@ -126,17 +126,17 @@ namespace lumiera { uint getQuality() const; bool usesProxy() const; - operator weak_ptr() const; + operator weak_ptr() const; }; - using ModelPorts = lib::IterSource::iterator; - using Pipes = lib::IterSource::iterator; - using Output = proc::play::POutputManager; - using Clip = proc::mobject::session::PClip; - using Fork = proc::mobject::PFork; - using Timeline = proc::asset::PTimeline; - using Viewer = proc::asset::PViewer; + using ModelPorts = lib::IterSource::iterator; + using Pipes = lib::IterSource::iterator; + using Output = steam::play::POutputManager; + using Clip = steam::mobject::session::PClip; + using Fork = steam::mobject::PFork; + using Timeline = steam::asset::PTimeline; + using Viewer = steam::asset::PViewer; /* ==== convenience shortcuts for common use cases ==== */ diff --git a/src/include/session-command-facade.h b/src/include/session-command-facade.h index bb7a255b5..a3692f8fb 100644 --- a/src/include/session-command-facade.h +++ b/src/include/session-command-facade.h @@ -33,14 +33,14 @@ ** accept the command arguments for binding packaged as `Record`. ** For each command, there needs to be a registration record within the ** Steam-Layer implementation. The service implementation backing this - ** facade indeed retrieves the corresponding proc::control::Command + ** facade indeed retrieves the corresponding steam::control::Command ** handles to perform the binding operation and hands them over ** to the ProcDispatcher for invocation. ** ** @see command.hpp ** @see session-command-service.hpp implementation - ** @see proc::control::ProcDispatcher - ** @see gui::ctrl::CoreService + ** @see steam::control::ProcDispatcher + ** @see stage::ctrl::CoreService */ @@ -68,7 +68,7 @@ namespace control { /**********************************************************************//** * Global access point to invoke commands and cause edit operations within * the Session. Any changes to the session are effected by prepared functors - * bound into a proc::control::Command registration. A command instance will + * bound into a steam::control::Command registration. A command instance will * first be outfitted with suitable parameters to define the target and to * qualify and elaborate the action, before it can be actually triggered. * Commands then go through a queue to be invoked one by one. diff --git a/src/include/ui-protocol.hpp b/src/include/ui-protocol.hpp index 17ebefaf7..9d920331a 100644 --- a/src/include/ui-protocol.hpp +++ b/src/include/ui-protocol.hpp @@ -27,7 +27,7 @@ ** running an asynchronous communication protocol. ** - the [UI-Bus](\ref ui-bus.hpp) allows for some specific kinds of messages to be ** sent either "upstream" (towards the CoreService) or "downstream" to individual - ** [UI-Elements](\ref gui::model::Tangible) known by ID. + ** [UI-Elements](\ref stage::model::Tangible) known by ID. ** - these ["tangible interface elements"](\ref tangible.hpp) themselves define a ** basic set of actions and "state mark" messages, known as the "element protocol" ** - and changes to the structure of tangible elements exposed through the UI are diff --git a/src/lib/call-queue.hpp b/src/lib/call-queue.hpp index 1b20ee381..b96bc4cfc 100644 --- a/src/lib/call-queue.hpp +++ b/src/lib/call-queue.hpp @@ -29,7 +29,7 @@ ** based on std::function; should use a lock-fee queue and should have an eye ** on the impact of managing argument storage ** - ** @see gui::NotificationService usage example + ** @see stage::NotificationService usage example */ diff --git a/src/lib/diff/mutation-message.hpp b/src/lib/diff/mutation-message.hpp index ff146cdac..5460def67 100644 --- a/src/lib/diff/mutation-message.hpp +++ b/src/lib/diff/mutation-message.hpp @@ -40,7 +40,7 @@ ** and transported through the message -- since a diff sequence as such is always concrete and relates to a ** a specific context, we can not represent it directly as a type on interface level. Rather, the receiver ** of a diff sequence must offer the ability to be reshaped through diff messages, which is expressed through - ** the interface DiffMutable. In the case at question here, gui::model::Tangible offers this interface and thus + ** the interface DiffMutable. In the case at question here, stage::model::Tangible offers this interface and thus ** the ability to construct a concrete lib::diff::TreeMutator, which in turn is bound to the internals of the ** actual UI-Element. In this framework, a diff is actually represented as a sequence of _diff verbs,_ which ** can be ``pulled'' one by one from the MutationMessage, and then applied to the target data structure diff --git a/src/lib/format-obj.cpp b/src/lib/format-obj.cpp index b7eb0d26a..44b0405a3 100644 --- a/src/lib/format-obj.cpp +++ b/src/lib/format-obj.cpp @@ -199,9 +199,9 @@ apologies for that." "|lib::diff::" "|lib::" "|util::" - "|proc::(asset::|mobject::(session::)?|play::)?" - "|gui::model" - "|gui::ctrl" + "|steam::(asset::|mobject::(session::)?|play::)?" + "|stage::model" + "|stage::ctrl" "|lumiera::" , regex::ECMAScript | regex::optimize}; diff --git a/src/lib/handle.hpp b/src/lib/handle.hpp index b46e340cb..0a05d34b8 100644 --- a/src/lib/handle.hpp +++ b/src/lib/handle.hpp @@ -35,7 +35,7 @@ ** of the implementation class the handle points at is necessary only in the ** translation unit implementing such an extended handle. ** - ** @see proc::control::Command usage example + ** @see steam::control::Command usage example ** */ diff --git a/src/lib/idi/entry-id.hpp b/src/lib/idi/entry-id.hpp index a32cf0978..24f4b6e36 100644 --- a/src/lib/idi/entry-id.hpp +++ b/src/lib/idi/entry-id.hpp @@ -35,7 +35,7 @@ ** @todo as of 11/2018 the basic design seems adequate, but the actual solution looks fishy. ** Even more so, since we now use subclasses of BareEntryID ** - as identity tag within lib::diff::GenNode - ** - as identity tag for all [tangible UI elements](\ref gui::model::Tangible) + ** - as identity tag for all [tangible UI elements](\ref stage::model::Tangible) ** There are various quirks and hacks to make all of this happen, and especially ** the hashed-in type information feels gratuitous at places, when all we actually ** need is a distinct identity plus a human readable symbol. diff --git a/src/lib/iter-explorer.hpp b/src/lib/iter-explorer.hpp index 153521da3..020903e1f 100644 --- a/src/lib/iter-explorer.hpp +++ b/src/lib/iter-explorer.hpp @@ -62,7 +62,7 @@ ** - the more low-level RecursiveSelfIntegration combinator strategy actually ** delegates to the result set iterator implementation to perform the collecting ** and re-integrating of intermediary results. This approach is what we actually - ** use in the proc::engine::Dispatcher + ** use in the steam::engine::Dispatcher ** ** Alternatively, just the basic IterExplorer template can be used together with a custom ** "combinator strategy" and typically even a specific iterator or sequence to implement very specific diff --git a/src/lib/maybe.hpp b/src/lib/maybe.hpp index 3e5444c9e..27e315cca 100644 --- a/src/lib/maybe.hpp +++ b/src/lib/maybe.hpp @@ -41,7 +41,7 @@ ** @todo WIP and rather brainstorming as of 2/10 ** @deprecated as of 2016 : the upcoming C++17 will provide an optional type!! ** - ** @see backend::ThreadJob usage example + ** @see vault::ThreadJob usage example */ diff --git a/src/lib/meta/configflags.hpp b/src/lib/meta/configflags.hpp index b7d8ba9ec..b2bcd336f 100644 --- a/src/lib/meta/configflags.hpp +++ b/src/lib/meta/configflags.hpp @@ -38,8 +38,8 @@ ** which would lead to more and more code bloat with growing number of possible ** combinations. ** - ** @see proc::engine::config::Strategy usage example - ** @see proc::engine::config::ConfigSelector + ** @see steam::engine::config::Strategy usage example + ** @see steam::engine::config::ConfigSelector ** @see typelist.hpp ** */ diff --git a/src/lib/path-array.hpp b/src/lib/path-array.hpp index 3d6054916..381a921cc 100644 --- a/src/lib/path-array.hpp +++ b/src/lib/path-array.hpp @@ -40,7 +40,7 @@ ** ** @see PathArray_test ** @see UICoord_test - ** @see gui::interact::UICoord + ** @see stage::interact::UICoord ** @see view-spec-dsl.hpp */ diff --git a/src/lib/priqueue.h b/src/lib/priqueue.h index 30c558aec..d5f1f5d63 100644 --- a/src/lib/priqueue.h +++ b/src/lib/priqueue.h @@ -35,7 +35,7 @@ ** any but the topmost element. The idea is to let expired elements sink to the top ** and just detect and remove them on next access. ** - ** @see backend::engine::SchedulerFrontend + ** @see vault::engine::SchedulerFrontend ** */ diff --git a/src/lib/replaceable-item.hpp b/src/lib/replaceable-item.hpp index 512abfbca..4392ed89a 100644 --- a/src/lib/replaceable-item.hpp +++ b/src/lib/replaceable-item.hpp @@ -50,7 +50,7 @@ ** by providing an explicit specialisation of lib::NullValue for this type. ** ** @see ReplaceableIterm_test - ** @see proc::control::MementoTie + ** @see steam::control::MementoTie ** */ diff --git a/src/lib/result.hpp b/src/lib/result.hpp index 7060c39ad..513340dc8 100644 --- a/src/lib/result.hpp +++ b/src/lib/result.hpp @@ -30,7 +30,7 @@ ** valid or failure state, which can be tested. Any attempt to get the value ** of an invalid result token will cause an exception to be thrown. ** - ** @see backend::ThreadJoinable usage example + ** @see vault::ThreadJoinable usage example */ diff --git a/src/lib/scoped-ptrvect.hpp b/src/lib/scoped-ptrvect.hpp index f14267f93..58fe20a64 100644 --- a/src/lib/scoped-ptrvect.hpp +++ b/src/lib/scoped-ptrvect.hpp @@ -39,7 +39,7 @@ ** ** @see scoped-ptrvect-test.cpp ** @see scoped-holder.hpp - ** @see gui::DisplayService usage example + ** @see stage::DisplayService usage example */ diff --git a/src/lib/test/microbenchmark.hpp b/src/lib/test/microbenchmark.hpp index 8d60f8b4f..b6bf9fd7a 100644 --- a/src/lib/test/microbenchmark.hpp +++ b/src/lib/test/microbenchmark.hpp @@ -87,7 +87,7 @@ namespace test{ inline double microbenchmark(FUN const& subject, const size_t nRepeat = DEFAULT_RUNS) { - using backend::ThreadJoinable; + using vault::ThreadJoinable; using std::chrono::system_clock; using Dur = std::chrono::duration; diff --git a/src/lib/wrapperptr.hpp b/src/lib/wrapperptr.hpp index 2ede7aca8..8205928e1 100644 --- a/src/lib/wrapperptr.hpp +++ b/src/lib/wrapperptr.hpp @@ -68,7 +68,7 @@ namespace lumiera { * @deprecated not sure if this was a good idea anyway. Better re-think how to handle wrapped objects in visitation * @todo really need to switch to the new lib::Variant and util::AccessCasted implementation ////////////////TICKET #450 */ - typedef lib::VariantO WrapperPtr; + typedef lib::VariantO WrapperPtr; diff --git a/src/lumiera/main.cpp b/src/lumiera/main.cpp index 938850562..34c7f7724 100644 --- a/src/lumiera/main.cpp +++ b/src/lumiera/main.cpp @@ -44,13 +44,13 @@ using lumiera::Subsys; using lumiera::AppState; namespace { - Subsys& engine = backend::EngineFacade::getDescriptor(); - Subsys& netNode = backend::NetNodeFacade::getDescriptor(); - Subsys& script = backend::ScriptRunnerFacade::getDescriptor(); + Subsys& engine = vault::EngineFacade::getDescriptor(); + Subsys& netNode = vault::NetNodeFacade::getDescriptor(); + Subsys& script = vault::ScriptRunnerFacade::getDescriptor(); Subsys& player = lumiera::DummyPlayer::getDescriptor(); ///////TODO: just a dummy, until we're able to render - Subsys& session = proc::Facade::getSessionDescriptor(); - Subsys& playOut = proc::Facade::getPlayOutDescriptor(); - Subsys& lumigui = gui::GuiFacade::getDescriptor(); + Subsys& session = steam::Facade::getSessionDescriptor(); + Subsys& playOut = steam::Facade::getPlayOutDescriptor(); + Subsys& lumigui = stage::GuiFacade::getDescriptor(); } diff --git a/src/stage/ctrl/bus-term.hpp b/src/stage/ctrl/bus-term.hpp index 2e9ed843e..6d3a6fd13 100644 --- a/src/stage/ctrl/bus-term.hpp +++ b/src/stage/ctrl/bus-term.hpp @@ -23,7 +23,7 @@ /** @file bus-term.hpp ** Attachment point to the UI-Bus. - ** Every gui::model::Tangible holds a BusTerm, which is linked + ** Every stage::model::Tangible holds a BusTerm, which is linked ** to the Tangible's identity, and serves to relay interface actions ** towards the Steam-Layer, to remember state changes and to broadcast ** notifications. Moreover, the BusTerm is the service point @@ -107,7 +107,7 @@ namespace ctrl{ { protected: using EntryID = lib::idi::BareEntryID; - using Tangible = gui::model::Tangible; + using Tangible = stage::model::Tangible; EntryID endpointID_; BusTerm& theBus_; diff --git a/src/stage/ctrl/core-service.hpp b/src/stage/ctrl/core-service.hpp index 71d844ce8..1e8c056a3 100644 --- a/src/stage/ctrl/core-service.hpp +++ b/src/stage/ctrl/core-service.hpp @@ -35,7 +35,7 @@ ** CoreService is a PImpl to manage all the technical parts of actual ** service provision. When it goes down, all services are decommissioned. ** A part of these lifecycle technicalities is to manage the setup of the - ** [UI-Bus main hub](\ref gui::ctrl::Nexus), which requires some trickery, + ** [UI-Bus main hub](\ref stage::ctrl::Nexus), which requires some trickery, ** since both CoreService and Nexus are mutually interdependent from an ** operational perspective, since they exchange messages in both directions. ** @@ -98,7 +98,7 @@ namespace stage { namespace ctrl{ - using proc::control::SessionCommand; + using steam::control::SessionCommand; using lib::diff::Rec; @@ -109,7 +109,7 @@ namespace ctrl{ * - commands need to be sent down to Steam-Layer * - presentation state messages need to be recorded and acted upon. * As an object, CoreService encases the heart of the UI-Bus, the - * \ref Nexus, and acts as "PImpl" for the gui::UiBus front-end. + * \ref Nexus, and acts as "PImpl" for the stage::UiBus front-end. */ class CoreService : public BusTerm diff --git a/src/stage/ctrl/state-recorder.hpp b/src/stage/ctrl/state-recorder.hpp index 346e531fc..fd8b9c30d 100644 --- a/src/stage/ctrl/state-recorder.hpp +++ b/src/stage/ctrl/state-recorder.hpp @@ -67,7 +67,7 @@ namespace stage { namespace ctrl { - using gui::ctrl::BusTerm; + using stage::ctrl::BusTerm; using lib::diff::GenNode; using lib::diff::Ref; using std::string; @@ -81,7 +81,7 @@ namespace ctrl { * Requires a permanent connection to the UI-Bus, * which is given as reference at construction. * The intention is to use such an implementation - * embedded within the gui::ctrl::CoreService, + * embedded within the stage::ctrl::CoreService, * which in turn then manages the lifecycle of * this UI-Bus connection. Besides, a derived * mock implementation is available through diff --git a/src/stage/dialog/test-control.hpp b/src/stage/dialog/test-control.hpp index 5fa348f64..6d212a58d 100644 --- a/src/stage/dialog/test-control.hpp +++ b/src/stage/dialog/test-control.hpp @@ -128,7 +128,7 @@ namespace dialog { * - define the wiring of the components within a page in the page's ctor * - possibly pass external dependencies for wiring into that ctor * @note the page widgets are actually heap allocated and managed automatically - * @see gui::dialog::TestControl as a usage example + * @see stage::dialog::TestControl as a usage example * * [Notebook]: https://developer.gnome.org/gtkmm-tutorial/stable/sec-multi-item-containers.html.en#sec-notebook */ @@ -266,13 +266,13 @@ namespace dialog { // define the action triggers... trig_1_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_meta_displayInfo, getLogLevel(), getContent())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_meta_displayInfo, getLogLevel(), getContent())); }); trig_2_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_meta_markError, getContent())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_meta_markError, getContent())); }); trig_3_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_meta_markNote, getContent())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_meta_markNote, getContent())); }); trig_4_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_meta_markAction, getActionID(), getContent())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_meta_markAction, getActionID(), getContent())); }); } }; @@ -328,9 +328,9 @@ namespace dialog { // define the action triggers... seq_1_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_fake_injectSequence_1, pickDummyID())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_fake_injectSequence_1, pickDummyID())); }); seq_2_.signal_clicked().connect( - [&]{ bus.act (model::commandMessage (proc::cmd::test_fake_injectSequence_2, pickDummyID())); }); + [&]{ bus.act (model::commandMessage (steam::cmd::test_fake_injectSequence_2, pickDummyID())); }); mut_1_.signal_clicked().connect( [&]{ cerr << "gelldaschaugst..." < (termSig)); + return stage::launchUI (*reinterpret_cast (termSig)); } ) ) diff --git a/src/stage/guifacade.hpp b/src/stage/guifacade.hpp index 91ef48af4..aa2b9a747 100644 --- a/src/stage/guifacade.hpp +++ b/src/stage/guifacade.hpp @@ -55,7 +55,7 @@ namespace stage { * Global access point for loading and starting up the Lumiera GTK GUI * and for controlling the GUI lifecycle. The implementation part of * this class also is responsible for making the "business" interface - * of the GUI available, i.e. gui::GuiNotification + * of the GUI available, i.e. stage::GuiNotification * * When running Lumiera with a GUI is required (the default case), * it is loaded as dynamic module, thus defining the interface(s) @@ -69,11 +69,11 @@ namespace stage { * is somewhat special, as its sole purpose is to expose the subsystem * descriptor, which, when started, loads the GUI as a plugin and * invokes `launchUI(term)` there. For the implementation see - * gui::GuiRunner (guifacade.cpp) and gtk-lumiera.cpp (the plugin). + * stage::GuiRunner (guifacade.cpp) and gtk-lumiera.cpp (the plugin). * * @note this facade is intended to be used by Lumiera main solely. * client code should always use the "business" interface(s): - * - gui::GuiNotification + * - stage::GuiNotification * */ class GuiFacade diff --git a/src/stage/id-scheme.hpp b/src/stage/id-scheme.hpp index a16a0f182..afcdaf4a3 100644 --- a/src/stage/id-scheme.hpp +++ b/src/stage/id-scheme.hpp @@ -97,7 +97,7 @@ namespace stage { template<> struct Descriptor { - using Model = proc::asset::Timeline; + using Model = steam::asset::Timeline; }; @@ -107,7 +107,7 @@ namespace stage { template<> struct Descriptor { - using Model = proc::asset::meta::ErrorLog; + using Model = steam::asset::meta::ErrorLog; ///////////////////////////////////////////////////////////////////////////////////////////TICKET #1105 : consider use of a DSL to configure component view access // diff --git a/src/stage/interact/interaction-director.cpp b/src/stage/interact/interaction-director.cpp index b89f7520d..ca5b95d99 100644 --- a/src/stage/interact/interaction-director.cpp +++ b/src/stage/interact/interaction-director.cpp @@ -76,8 +76,8 @@ using util::toString; namespace stage { namespace interact { - namespace session = proc::mobject::session; - namespace cmd = proc::cmd; + namespace session = steam::mobject::session; + namespace cmd = steam::cmd; using ctrl::GlobalCtx; using ctrl::UiState; @@ -188,7 +188,7 @@ namespace interact { void InteractionDirector::saveSnapshot() { - string snapshotID{"snap-" + toString(backend::RealClock::now())}; + string snapshotID{"snap-" + toString(vault::RealClock::now())}; invoke (cmd::session_saveSnapshot, snapshotID); } @@ -277,7 +277,7 @@ namespace interact { InteractionDirector::newSequence() { LuidH anchor{*this}; /////////////////////////////////////////////////////////////////TICKET #1082 : actually access the interaction state to get "current scope" - LuidH newSeqID{EntryID().getHash()}; ////////////////////////////////////////////TICKET #1096 : a better Idea what to send over the wire? + LuidH newSeqID{EntryID().getHash()}; ////////////////////////////////////////////TICKET #1096 : a better Idea what to send over the wire? invoke (cmd::session_newSequence, anchor, newSeqID); } @@ -301,7 +301,7 @@ namespace interact { InteractionDirector::newTrack() { LuidH anchor{*this}; /////////////////////////////////////////////////////////////////TICKET #1082 : actually access the interaction state to get "current scope" - LuidH newTrackID{EntryID().getHash()}; ///////////////////////////////////TICKET #1096 : a better Idea what to send over the wire? + LuidH newTrackID{EntryID().getHash()}; ///////////////////////////////////TICKET #1096 : a better Idea what to send over the wire? invoke (cmd::sequence_newTrack, anchor, newTrackID); } diff --git a/src/stage/interact/ui-coord-resolver.hpp b/src/stage/interact/ui-coord-resolver.hpp index c8903edd2..7c1d04c8b 100644 --- a/src/stage/interact/ui-coord-resolver.hpp +++ b/src/stage/interact/ui-coord-resolver.hpp @@ -43,7 +43,7 @@ ** the next level of child iteration at its place, similar to the `flatMap` ** operation known from functional programming. ** Together, these two capabilities allow us to build exploring and backtracking evaluations, - ** which is enough to build a secondary helper component on top, the gui::interact::UICoordResolver + ** which is enough to build a secondary helper component on top, the stage::interact::UICoordResolver ** ** ** # UI coordinate path evaluation @@ -53,7 +53,7 @@ ** followed by traversal of the coordinate spec and matching against a navigation path within the actual UI window ** configuration. This process might involve interpretation of some meta-symbols and interpolation of wildcards. ** - ** As indicated above, the coordinate resolver internally relies on a [context query interface](\ref gui::interact::LocationQuery), + ** As indicated above, the coordinate resolver internally relies on a [context query interface](\ref stage::interact::LocationQuery), ** to find out about existing windows, panels, views and tabs and to navigate the real UI structure. The actual ** implementation of this context query interface is backed by the \ref Navigator component exposed through the ** \ref InteractionDirector. diff --git a/src/stage/interact/view-locator.cpp b/src/stage/interact/view-locator.cpp index 46f7762a3..b8c02ab3b 100644 --- a/src/stage/interact/view-locator.cpp +++ b/src/stage/interact/view-locator.cpp @@ -53,9 +53,9 @@ //using util::cStr; //using util::isnil; using lib::Symbol; -//using gui::ctrl::PanelLocator; -//using gui::ctrl::WindowLocator; -using gui::model::ElementAccess; +//using stage::ctrl::PanelLocator; +//using stage::ctrl::WindowLocator; +using stage::model::ElementAccess; namespace stage { diff --git a/src/stage/interact/view-locator.hpp b/src/stage/interact/view-locator.hpp index 1f500af9b..ba3ec21f1 100644 --- a/src/stage/interact/view-locator.hpp +++ b/src/stage/interact/view-locator.hpp @@ -42,7 +42,7 @@ ** thus relies on a framework for default configuration, and a matching mechanism to determine the location and ** creation modes of such views. This matching mechanism in turn requires an abstracted view on the UI seen as ** a topological tree structure of relevant entities (windows, panels, views,...) -- which is basically the - ** service provided by the Navigator; yet this Navigator service can be abstracted into the gui::interact::LocationQuery + ** service provided by the Navigator; yet this Navigator service can be abstracted into the stage::interact::LocationQuery ** API, and this abstraction allows to keep all the intricacies of navigating concrete UI widgets confined within the ** implementation of the Navigator service. ** diff --git a/src/stage/interact/view-spec-dsl.hpp b/src/stage/interact/view-spec-dsl.hpp index 332f74322..c33e3f445 100644 --- a/src/stage/interact/view-spec-dsl.hpp +++ b/src/stage/interact/view-spec-dsl.hpp @@ -276,7 +276,7 @@ namespace idi { * These are (singleton) instances of idi::Descriptor, and assumed to expose * - a member `viewSpec.locate`, which solves for the actual view location within UI topology * - a member `viewSpec.alloc`, which actually claims / allocates an existing or new view instance - * @see gui::ctrl::ViewLocator::get + * @see stage::ctrl::ViewLocator::get */ template inline Descriptor& diff --git a/src/stage/interact/wizard.hpp b/src/stage/interact/wizard.hpp index 6179a1608..33311d5bc 100644 --- a/src/stage/interact/wizard.hpp +++ b/src/stage/interact/wizard.hpp @@ -96,7 +96,7 @@ namespace interact { void show_HelpAbout(); void launchTestCtrl(); - static ID getErrorLogID() { return proc::asset::meta::theErrorLog_ID; } + static ID getErrorLogID() { return steam::asset::meta::theErrorLog_ID; } private: }; diff --git a/src/stage/model/controller.hpp b/src/stage/model/controller.hpp index 43318a7c4..b8827a070 100644 --- a/src/stage/model/controller.hpp +++ b/src/stage/model/controller.hpp @@ -29,7 +29,7 @@ ** especially, there might be a default (NOP) implementation of the diff mutator builder ** ** @see model::Tangible - ** @see gui::UIBus + ** @see stage::UIBus ** @see ////TODO_test usage example ** */ diff --git a/src/stage/model/element-access.hpp b/src/stage/model/element-access.hpp index 2b411a130..df89410cf 100644 --- a/src/stage/model/element-access.hpp +++ b/src/stage/model/element-access.hpp @@ -80,7 +80,7 @@ namespace model { /** * Interface: access UI elements by navigating the UI topology. * - * @see gui::interact::Navigator + * @see stage::interact::Navigator * @see ElementAccess_test */ class ElementAccess diff --git a/src/stage/model/flash-deco.hpp b/src/stage/model/flash-deco.hpp index 4c646139a..e226a4944 100644 --- a/src/stage/model/flash-deco.hpp +++ b/src/stage/model/flash-deco.hpp @@ -53,7 +53,7 @@ namespace model { * Decorator for a Gtk::Widget to add a visual flash action. * @tparam WIT type of the target widget to decorate. All ctors are passed through. * @remark invoke the #flash function to trigger - * @see \ref gui::CSS_CLASS_FLASH + * @see \ref stage::CSS_CLASS_FLASH */ template class FlashDeco diff --git a/src/stage/model/widget.hpp b/src/stage/model/widget.hpp index 5e0f04cac..d27bf950a 100644 --- a/src/stage/model/widget.hpp +++ b/src/stage/model/widget.hpp @@ -26,7 +26,7 @@ ** ** @todo as of 1/2015 this is complete WIP-WIP-WIP ** - ** @see gui::model::Tangible + ** @see stage::model::Tangible ** @see ////TODO_test usage example ** */ diff --git a/src/stage/notification-service.cpp b/src/stage/notification-service.cpp index 1d09065f0..1547eae37 100644 --- a/src/stage/notification-service.cpp +++ b/src/stage/notification-service.cpp @@ -76,8 +76,8 @@ extern "C" { using lib::diff::GenNode; using lib::diff::TreeMutator; using lib::diff::MutationMessage; -using gui::ctrl::UiDispatcher; -using gui::ctrl::BusTerm; +using stage::ctrl::UiDispatcher; +using stage::ctrl::BusTerm; using util::cStr; using util::_Fmt; diff --git a/src/stage/notification-service.hpp b/src/stage/notification-service.hpp index 661c21830..09b5d466f 100644 --- a/src/stage/notification-service.hpp +++ b/src/stage/notification-service.hpp @@ -21,18 +21,18 @@ */ /** @file notification-service.hpp - ** A public service provided by the GUI, implementing the gui::GuiNotification facade interface. + ** A public service provided by the GUI, implementing the stage::GuiNotification facade interface. ** The purpose of this service is to push state update and notification of events from the lower ** layers into the Lumiera GUI. Typically, this happens asynchronously and triggered either by ** events within the lower layers, or as result of invoking commands on the session. ** ** This service is the implementation of a layer separation facade interface. Clients should use - ** gui::GuiNotification#facade to access this service. This header here defines the interface + ** stage::GuiNotification#facade to access this service. This header here defines the interface ** used to _provide_ this service, not to access it. ** - ** @see gui::GuiFacade launching the Lumiera UI + ** @see stage::GuiFacade launching the Lumiera UI ** @see facade.hpp RAII holder to start this service and open the interface - ** @see gui::ctrl::UiManager::performMainLoop() exposes all UI façade interfaces + ** @see stage::ctrl::UiManager::performMainLoop() exposes all UI façade interfaces */ diff --git a/src/stage/panel/timeline-panel-obsolete.cpp b/src/stage/panel/timeline-panel-obsolete.cpp index 7eb17d4f7..37254e3fb 100644 --- a/src/stage/panel/timeline-panel-obsolete.cpp +++ b/src/stage/panel/timeline-panel-obsolete.cpp @@ -39,8 +39,8 @@ using namespace stage::widget; using namespace stage::widget::timeline; using namespace stage::model; -using gui::controller::Controller; -using gui::ctrl::PlaybackController; +using stage::controller::Controller; +using stage::ctrl::PlaybackController; using std::shared_ptr; using std::weak_ptr; using util::contains; @@ -70,7 +70,7 @@ namespace panel { , zoomOut(Stock::ZOOM_OUT) , zoomScale() , updatingToolbar(false) - , currentTool(gui::widget::timeline::Arrow) + , currentTool(stage::widget::timeline::Arrow) { // Hook up notifications obsoleteProject_.get_sequences().signal_changed().connect(mem_fun(this, @@ -184,13 +184,13 @@ namespace panel { void TimelinePanelObsolete::on_arrow_tool() { - setTool(gui::widget::timeline::Arrow); + setTool(stage::widget::timeline::Arrow); } void TimelinePanelObsolete::on_ibeam_tool() { - setTool(gui::widget::timeline::IBeam); + setTool(stage::widget::timeline::IBeam); } void @@ -329,8 +329,8 @@ namespace panel { if (!updatingToolbar) { updatingToolbar = true; - arrowTool.set_active (currentTool == gui::widget::timeline::Arrow); - iBeamTool.set_active (currentTool == gui::widget::timeline::IBeam); + arrowTool.set_active (currentTool == stage::widget::timeline::Arrow); + iBeamTool.set_active (currentTool == stage::widget::timeline::IBeam); updatingToolbar = false; } } diff --git a/src/stage/panel/timeline-panel-obsolete.hpp b/src/stage/panel/timeline-panel-obsolete.hpp index f066fa99a..1e2bf97b2 100644 --- a/src/stage/panel/timeline-panel-obsolete.hpp +++ b/src/stage/panel/timeline-panel-obsolete.hpp @@ -114,7 +114,7 @@ namespace model{ bool is_playing(); - void setTool (gui::widget::timeline::ToolType tool); + void setTool (stage::widget::timeline::ToolType tool); void showTime (Time); @@ -188,13 +188,13 @@ namespace model{ MiniButton zoomIn; MiniButton zoomOut; - gui::widget::timeline::TimelineZoomScale zoomScale; + stage::widget::timeline::TimelineZoomScale zoomScale; Gtk::SeparatorToolItem separator2; // Internals bool updatingToolbar; - gui::widget::timeline::ToolType currentTool; + stage::widget::timeline::ToolType currentTool; private: // TEST CODE diff --git a/src/stage/panel/timeline-panel.hpp b/src/stage/panel/timeline-panel.hpp index 6b0a4fcc4..8ec19dd61 100644 --- a/src/stage/panel/timeline-panel.hpp +++ b/src/stage/panel/timeline-panel.hpp @@ -30,8 +30,8 @@ ** manages a collection of timelines. The timeline panel exposes this collection and allows to view and ** interact with one of the given timelines. The build-up of the timeline display and thus the initiative ** to expose a timeline comes from the interaction director -- but as usual with graphical user interfaces, - ** any user interaction after this point is handled autonomously by the gui::timeline::TimelineWidget and - ** gui::timeline::TimelineController + ** any user interaction after this point is handled autonomously by the stage::timeline::TimelineWidget and + ** stage::timeline::TimelineController ** ** @todo as of 10/2016 this is WIP-WIP-WIP : canvas widgets experiment ** @todo as of 10/2018 we start to build a new timeline widget, connected to the UI-Bus diff --git a/src/stage/setting/asset-controller.hpp b/src/stage/setting/asset-controller.hpp index 33770d389..ce868ef95 100644 --- a/src/stage/setting/asset-controller.hpp +++ b/src/stage/setting/asset-controller.hpp @@ -40,8 +40,8 @@ ** ** @todo WIP 2/2017 early draft / a new UI backbone ** - ** @see proc::mobject::Session - ** @see proc::asset::Asset + ** @see steam::mobject::Session + ** @see steam::asset::Asset ** @see timeline-controller.hpp ** @see interaction-director.hpp ** @see ui-bus.hpp diff --git a/src/stage/style-scheme.cpp b/src/stage/style-scheme.cpp index 986b37d25..7913ecd01 100644 --- a/src/stage/style-scheme.cpp +++ b/src/stage/style-scheme.cpp @@ -24,7 +24,7 @@ /** @file style-scheme.hpp ** Definition of access keys for uniform UI styling. ** - ** @see gui::workspace::UiStyle + ** @see stage::workspace::UiStyle ** */ diff --git a/src/stage/timeline/clip-presenter.hpp b/src/stage/timeline/clip-presenter.hpp index 3db3f3a1f..e9eb083f9 100644 --- a/src/stage/timeline/clip-presenter.hpp +++ b/src/stage/timeline/clip-presenter.hpp @@ -30,7 +30,7 @@ ** as known from the [MVP pattern](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter) -- ** serves as link between both levels. For the global angle of view, it is a model::Tangible and thus ** plays the role of the _View_, while the _Model_ and _Controler_ roles are mediated through the - ** gui::UiBus, exchanging command, state and mutation messages. On the other hand, for the local + ** stage::UiBus, exchanging command, state and mutation messages. On the other hand, for the local ** angle of view, the _Presenter_ is a structural model element, kind of a _view model_, and corresponds ** to the respective element within the session. In addition, it manages actively the collaborative ** part of layout building, delegating to a mostly passive GTK widget for the actual display. diff --git a/src/stage/timeline/timeline-controller.cpp b/src/stage/timeline/timeline-controller.cpp index 4dfe1616c..dae84592c 100644 --- a/src/stage/timeline/timeline-controller.cpp +++ b/src/stage/timeline/timeline-controller.cpp @@ -130,7 +130,7 @@ namespace timeline { * as a nested scope. * For both cases we prepare a way to build a _nested mutator_, and in both cases this * is simply achieved by relying on the common interface of all those "elements", which - * is gui::model::Tangible and just happens to require each such "tangible" to offer + * is stage::model::Tangible and just happens to require each such "tangible" to offer * a mutation building method, just like this one here. Simple recursive programming. * @see DiffComplexApplication_test */ diff --git a/src/stage/timeline/timeline-gui.cpp b/src/stage/timeline/timeline-gui.cpp index e48a1f2da..c66fbcf3d 100644 --- a/src/stage/timeline/timeline-gui.cpp +++ b/src/stage/timeline/timeline-gui.cpp @@ -27,8 +27,8 @@ ** actual object construction are defined within this dedicated translation unit. ** ** @see TimelineWidget - ** @see gui::interact::InteractionDirector::buildMutator - ** @see gui::timeline::TimelineController::buildMutator + ** @see stage::interact::InteractionDirector::buildMutator + ** @see stage::timeline::TimelineController::buildMutator ** */ @@ -88,7 +88,7 @@ namespace timeline { * unique_ptr right here, which can than be handed over to TimelinePanel, * yet still we _do inherit_ from WLink, i.e. expose the subclass. * The `unque_ptr` owns and manages the TimelineWidget, which is itself non-copyable - * and stays at a fixed location in heap memory, as is required by gui::ctrl::Nexus + * and stays at a fixed location in heap memory, as is required by stage::ctrl::Nexus * to maintain a registration of the UI-Bus connection. WLink to the contrary * just connects to the widget, and is automatically disconnected when it dies. */ diff --git a/src/stage/timeline/timeline-gui.hpp b/src/stage/timeline/timeline-gui.hpp index c8925b809..0b22a6f7b 100644 --- a/src/stage/timeline/timeline-gui.hpp +++ b/src/stage/timeline/timeline-gui.hpp @@ -43,8 +43,8 @@ ** initially, or in answer to a population request originating from within the UI, prompted by the ** need to expose some timeline at a given place within the interface. ** - ** @see gui::interact::InteractionDirector::buildMutator - ** @see gui::timeline::TimelineWidget + ** @see stage::interact::InteractionDirector::buildMutator + ** @see stage::timeline::TimelineWidget ** */ diff --git a/src/stage/timeline/timeline-widget.hpp b/src/stage/timeline/timeline-widget.hpp index 75a9d5faf..6777be5f3 100644 --- a/src/stage/timeline/timeline-widget.hpp +++ b/src/stage/timeline/timeline-widget.hpp @@ -36,7 +36,7 @@ ** # Lifecycle ** The assumption is that any element creation and deletion is triggered through messages over ** the [UI-Bus](\ref ui-bus.hpp). So there will be a _parent element,_ corresponding to the - ** [model root](\ref proc::mobject::session::Root), and this parent, in response to some + ** [model root](\ref steam::mobject::session::Root), and this parent, in response to some ** mutation message, will create a TimelineWidget, add it into the appropriate GTK display setup ** and manage it as child element; the [construction parameters](\ref TimelineWidget::TimelineWidget) ** ensure it gets connected to the bus as well. Incidentally, this assumption also implies that @@ -128,7 +128,7 @@ namespace timeline { * the one that created it, typically also in response to a message. * Non the less it is possible just to delete a TimelineWidget, since * it is a Gtk::Widget, and the controller is also `sigc::trackable` - * and additionally, as a gui::model::Tangible, it will deregister + * and additionally, as a stage::model::Tangible, it will deregister * automatically from the UI-Bus. After that, any further messages * towards this element will be dropped silently. */ diff --git a/src/stage/timeline/track-presenter.hpp b/src/stage/timeline/track-presenter.hpp index 476e6e991..555104332 100644 --- a/src/stage/timeline/track-presenter.hpp +++ b/src/stage/timeline/track-presenter.hpp @@ -30,7 +30,7 @@ ** as known from the [MVP pattern](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93presenter) -- ** serves as link between both levels. For the global angle of view, it is a model::Tangible and thus ** plays the role of the _View_, while the _Model_ and _Controler_ roles are mediated through the - ** gui::UiBus, exchanging command, state and mutation messages. On the other hand, for the local + ** stage::UiBus, exchanging command, state and mutation messages. On the other hand, for the local ** angle of view, the _Presenter_ is a structural model element, kind of a _view model_, and corresponds ** to the respective element within the session. In addition, it manages actively the collaborative ** part of layout building, delegating to a mostly passive GTK widget for the actual display. diff --git a/src/stage/ui-bus.cpp b/src/stage/ui-bus.cpp index 149194997..c1136b4f1 100644 --- a/src/stage/ui-bus.cpp +++ b/src/stage/ui-bus.cpp @@ -26,7 +26,7 @@ ** Implementation of the UI backbone service for messaging. ** Any globally relevant widget or controller within the Lumiera UI ** is connected to the [UI-Bus](\ref ui-bus.hpp), which is essentially implemented - ** within this compilation unit. [Clients](\ref gui::model::Tangible) typically + ** within this compilation unit. [Clients](\ref stage::model::Tangible) typically ** use the [BusTerm-Interface](\ref bus-term.hpp) to route generic actions and ** receive notifications, state changes and mutations. ** @@ -123,7 +123,7 @@ namespace ctrl { * @remarks some commands can simply be invoked right away, but * in the general case, a command needs to be prepared with * suitable arguments prior to being invoked, which can be - * a multi-step process. The gui::interact::InteractionState + * a multi-step process. The stage::interact::InteractionState * is used to conduct this argument binding process from within * the UI. Here, at the UI-Bus interface, we're just interested * in the fact _that_ some command is to be bound and invoked. @@ -132,8 +132,8 @@ namespace ctrl { * @note no information regarding the _origin_ of this command invocation * is captured. If a command needs a _subject_, this has to be * bound as an command argument beforehand. - * @see gui::model::Tangible::issueCommand() - * @see proc::control::SessionCommand + * @see stage::model::Tangible::issueCommand() + * @see steam::control::SessionCommand */ void BusTerm::act (GenNode const& command) @@ -164,9 +164,9 @@ namespace ctrl { /** route a state update or notification to the given subject. * @param subject the [endpoint-ID](\ref BusTerm::endpointID_) of the element to address * @param mark the actual state update or notification message to be delivered - * @remarks each addressed "subject" is a gui::model::Tangible, and as such holds + * @remarks each addressed "subject" is a stage::model::Tangible, and as such holds * a BusTerm of its own, which in turn ensures a registration and connection - * from the [central routing hub](\ref gui::ctrl::Nexus) down to the element. Thus, + * from the [central routing hub](\ref stage::ctrl::Nexus) down to the element. Thus, * the default implementation is just to pass the given state mark "up", * assuming that it will reach the hub eventually, which in turn knows * how to reach the element, and invoke the Tangible::mark() operation. diff --git a/src/stage/ui-bus.hpp b/src/stage/ui-bus.hpp index 82ab047f7..5f47a60e6 100644 --- a/src/stage/ui-bus.hpp +++ b/src/stage/ui-bus.hpp @@ -26,7 +26,7 @@ ** The Lumiera GTK GUI is built around a generic backbone structure known as **UI-Bus**. ** This is a messaging system and taps into any widget of more than local relevance. ** To that end, any globally relevant (custom) widget, and all secondary controllers - ** inherit from the gui::model::Tangible base. The top-level gui::UiBus element is + ** inherit from the stage::model::Tangible base. The top-level stage::UiBus element is ** a front-end and framework component managed by the [GTK-main](\ref GtkLumiera::main). ** ** @warning as of 12/2016, this is still totally a mess. This \em will remain @@ -68,7 +68,7 @@ ** ** - *act*: send a [GenNode] representing the action ** - the ID is either a globally registered command-ID or an explicitly - ** ["opened"](\ref proc::control::SessionCommand::cycle(Symbol,string)) command instance ID. + ** ["opened"](\ref steam::control::SessionCommand::cycle(Symbol,string)) command instance ID. ** - the payload is a Record holding the actual command arguments ** - on reception, an _instance_ (anonymous clone copy) of the command is created, bound ** with the arguments and handed over to the ProcDispatcher to be enqueued for execution. diff --git a/src/stage/widget/bin-widget.hpp b/src/stage/widget/bin-widget.hpp index 5ad38803d..1a1d50dfc 100644 --- a/src/stage/widget/bin-widget.hpp +++ b/src/stage/widget/bin-widget.hpp @@ -27,7 +27,7 @@ ** to organise various "things", like clips, media, effect plugins, labels ** sequences, processing patterns and also other nested bins. In the Lumiera ** session model, media bins and tracks are visual renderings of the same entity, - ** a [grouping fork](\ref proc::mobject::session::Fork). This wide array of + ** a [grouping fork](\ref steam::mobject::session::Fork). This wide array of ** possible usage gives rise to some complexity and several display styles, ranging ** from a simple list to a working area to arrange elements, with drag-n-drop ** support, searching and establishing of an element order. The generality diff --git a/src/stage/widget/button-bar.cpp b/src/stage/widget/button-bar.cpp index 8cae79e58..56531de94 100644 --- a/src/stage/widget/button-bar.cpp +++ b/src/stage/widget/button-bar.cpp @@ -47,4 +47,4 @@ namespace widget { } -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/button-bar.hpp b/src/stage/widget/button-bar.hpp index fa62eef84..8d55dba56 100644 --- a/src/stage/widget/button-bar.hpp +++ b/src/stage/widget/button-bar.hpp @@ -60,5 +60,5 @@ namespace widget { }; -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_BUTTON_BAR_H*/ diff --git a/src/stage/widget/error-log-display.hpp b/src/stage/widget/error-log-display.hpp index a0de35240..e5af57edb 100644 --- a/src/stage/widget/error-log-display.hpp +++ b/src/stage/widget/error-log-display.hpp @@ -273,7 +273,7 @@ namespace widget { /** temporarily change display style to prompt for attention; * set callback-timeout for return to normal state. - * @see \ref gui::CSS_CLASS_FLASH + * @see \ref stage::CSS_CLASS_FLASH */ void triggerFlash() diff --git a/src/stage/widget/menu-button.cpp b/src/stage/widget/menu-button.cpp index e0265abdb..9a7747ecd 100644 --- a/src/stage/widget/menu-button.cpp +++ b/src/stage/widget/menu-button.cpp @@ -206,4 +206,4 @@ namespace widget { } -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/menu-button.hpp b/src/stage/widget/menu-button.hpp index dde47e8e7..1bba155df 100644 --- a/src/stage/widget/menu-button.hpp +++ b/src/stage/widget/menu-button.hpp @@ -169,5 +169,5 @@ namespace widget { }; -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_MENU_BUTTON_H*/ diff --git a/src/stage/widget/mini-button.hpp b/src/stage/widget/mini-button.hpp index 8ccf44fa6..b030b6b61 100644 --- a/src/stage/widget/mini-button.hpp +++ b/src/stage/widget/mini-button.hpp @@ -86,5 +86,5 @@ namespace widget { -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_MINI_BUTTON_H*/ diff --git a/src/stage/widget/panel-bar.cpp b/src/stage/widget/panel-bar.cpp index 56858c553..84380c142 100644 --- a/src/stage/widget/panel-bar.cpp +++ b/src/stage/widget/panel-bar.cpp @@ -162,4 +162,4 @@ namespace widget { } -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/panel-bar.hpp b/src/stage/widget/panel-bar.hpp index 0c7e2c3a7..3945ab60a 100644 --- a/src/stage/widget/panel-bar.hpp +++ b/src/stage/widget/panel-bar.hpp @@ -113,5 +113,5 @@ namespace stage { -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_PANEL_BAR_H*/ diff --git a/src/stage/widget/timecode-widget.cpp b/src/stage/widget/timecode-widget.cpp index c0b55baa0..76952f446 100644 --- a/src/stage/widget/timecode-widget.cpp +++ b/src/stage/widget/timecode-widget.cpp @@ -1404,4 +1404,4 @@ namespace widget { -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/timecode-widget.hpp b/src/stage/widget/timecode-widget.hpp index cf919061f..c36000197 100644 --- a/src/stage/widget/timecode-widget.hpp +++ b/src/stage/widget/timecode-widget.hpp @@ -217,5 +217,5 @@ namespace widget { -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_TIMECODE_WIDGET_H*/ diff --git a/src/stage/widget/timeline-widget.cpp b/src/stage/widget/timeline-widget.cpp index d9b010319..9bafcc540 100644 --- a/src/stage/widget/timeline-widget.cpp +++ b/src/stage/widget/timeline-widget.cpp @@ -24,7 +24,7 @@ /** @file widget/timeline-widget.cpp ** ** @deprecated as of 11/2016, a complete rework of the timeline display is underway - ** @see gui::timeline::TimelineWidget new timeline display + ** @see stage::timeline::TimelineWidget new timeline display ** */ @@ -556,4 +556,4 @@ namespace widget { } -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/timeline-widget.hpp b/src/stage/widget/timeline-widget.hpp index da7a9b628..3d08441eb 100644 --- a/src/stage/widget/timeline-widget.hpp +++ b/src/stage/widget/timeline-widget.hpp @@ -30,7 +30,7 @@ ** Moreover, this class is designed way to monolithic. ** It will never be able to scale to the full planned ** timeline and editing functionality of Lumiera - ** @see gui::timeline::TimelineWidget new timeline display + ** @see stage::timeline::TimelineWidget new timeline display */ @@ -63,7 +63,7 @@ namespace widget { /** namespace of timeline widget helper classes. * @deprecated as of 11/2016, a complete rework of the timeline display is underway - * @see (\ref gui::timeline) namespace of the new timeline display + * @see (\ref stage::timeline) namespace of the new timeline display */ namespace timeline {} @@ -310,5 +310,5 @@ namespace widget { }; -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_TIMELINE_WIDGET_H*/ diff --git a/src/stage/widget/timeline/timeline-body.cpp b/src/stage/widget/timeline/timeline-body.cpp index 8aa2b4527..e9194f1b5 100644 --- a/src/stage/widget/timeline/timeline-body.cpp +++ b/src/stage/widget/timeline/timeline-body.cpp @@ -42,7 +42,7 @@ using namespace Gtk; /////////////////////////////////////////////////// using namespace std; ///////////////////////////////////////////////////////////////////////////////TICKET #1071 no wildcard includes please! using namespace lumiera; ///////////////////////////////////////////////////////////////////////////////TICKET #1071 no wildcard includes please! -using gui::draw::CairoUtil; +using stage::draw::CairoUtil; using std::shared_ptr; namespace stage { diff --git a/src/stage/widget/timeline/timeline-body.hpp b/src/stage/widget/timeline/timeline-body.hpp index 6db0f6bbd..717be3bda 100644 --- a/src/stage/widget/timeline/timeline-body.hpp +++ b/src/stage/widget/timeline/timeline-body.hpp @@ -68,7 +68,7 @@ public: * @param timeline_widget A reference to the owner widget of this * ruler. */ - TimelineBody(gui::widget::TimelineWidget &timeline_widget); + TimelineBody(stage::widget::TimelineWidget &timeline_widget); virtual ~TimelineBody(); @@ -203,7 +203,7 @@ private: float selectionAlpha; Cairo::RefPtr playbackPointColour; - gui::widget::TimelineWidget &timelineWidget; + stage::widget::TimelineWidget &timelineWidget; shared_ptr timelineState; diff --git a/src/stage/widget/timeline/timeline-header-container.cpp b/src/stage/widget/timeline/timeline-header-container.cpp index a3bbec4da..0619d8390 100644 --- a/src/stage/widget/timeline/timeline-header-container.cpp +++ b/src/stage/widget/timeline/timeline-header-container.cpp @@ -53,7 +53,7 @@ namespace timeline { // ===== Implementation ===== // - TimelineHeaderContainer::TimelineHeaderContainer(gui::widget::TimelineWidget &timeline_widget) + TimelineHeaderContainer::TimelineHeaderContainer(stage::widget::TimelineWidget &timeline_widget) : Glib::ObjectBase("TimelineHeaderContainer") , timelineWidget(timeline_widget) { diff --git a/src/stage/widget/timeline/timeline-header-container.hpp b/src/stage/widget/timeline/timeline-header-container.hpp index 3da423ee1..6d6aee088 100644 --- a/src/stage/widget/timeline/timeline-header-container.hpp +++ b/src/stage/widget/timeline/timeline-header-container.hpp @@ -56,7 +56,7 @@ namespace stage { : public Gtk::Container { public: - TimelineHeaderContainer(gui::widget::TimelineWidget &timeline_widget); + TimelineHeaderContainer(stage::widget::TimelineWidget &timeline_widget); /** * Attaches the header all the header widgets of root @@ -216,7 +216,7 @@ namespace stage { /** * The owner TimelineWidget of which this class is a helper */ - gui::widget::TimelineWidget &timelineWidget; + stage::widget::TimelineWidget &timelineWidget; /** * The widget's window object. @@ -267,7 +267,7 @@ namespace stage { */ static const int ScrollSlideEventInterval; - friend class gui::widget::TimelineWidget; + friend class stage::widget::TimelineWidget; friend class timeline::Track; }; diff --git a/src/stage/widget/timeline/timeline-header-widget.cpp b/src/stage/widget/timeline/timeline-header-widget.cpp index c2b5b4cbb..508020912 100644 --- a/src/stage/widget/timeline/timeline-header-widget.cpp +++ b/src/stage/widget/timeline/timeline-header-widget.cpp @@ -239,7 +239,7 @@ namespace timeline { bool hovering = false; const Gdk::Rectangle box = get_allocation(); - if (gui::draw::pt_in_rect (Gdk::Point(event->x, event->y), + if (stage::draw::pt_in_rect (Gdk::Point(event->x, event->y), Gdk::Rectangle(margin, margin, expand_button_size, box.get_height() - margin * 2))) diff --git a/src/stage/widget/timeline/timeline-layout-helper.cpp b/src/stage/widget/timeline/timeline-layout-helper.cpp index 1cf167c79..e986040e1 100644 --- a/src/stage/widget/timeline/timeline-layout-helper.cpp +++ b/src/stage/widget/timeline/timeline-layout-helper.cpp @@ -119,7 +119,7 @@ namespace timeline { BOOST_FOREACH( pair, headerBoxes ) { // Hit test the rectangle - if (gui::draw::pt_in_rect (point, pair.second)) + if (stage::draw::pt_in_rect (point, pair.second)) return shared_ptr(pair.first); } diff --git a/src/stage/widget/timeline/timeline-layout-helper.hpp b/src/stage/widget/timeline/timeline-layout-helper.hpp index 27385c9e0..34ea7a4f6 100644 --- a/src/stage/widget/timeline/timeline-layout-helper.hpp +++ b/src/stage/widget/timeline/timeline-layout-helper.hpp @@ -58,7 +58,7 @@ namespace stage { * A helper class for the TimelineWidget. TimelineLayoutHelper * is a class which calculates the layout of tracks in the timeline * track tree. - * @see gui::widget::TimelineWidget + * @see stage::widget::TimelineWidget */ class TimelineLayoutHelper : util::NonCopyable diff --git a/src/stage/widget/timeline/timeline-ruler.cpp b/src/stage/widget/timeline/timeline-ruler.cpp index 8818ce43d..a8191d802 100644 --- a/src/stage/widget/timeline/timeline-ruler.cpp +++ b/src/stage/widget/timeline/timeline-ruler.cpp @@ -43,7 +43,7 @@ using namespace stage::widget; ///////////////////////////////////////////// using namespace stage::widget::timeline; ///////////////////////////////////////////////////////////////////////////////TICKET #1071 no wildcard includes please! using std::shared_ptr; -using gui::draw::CairoUtil; +using stage::draw::CairoUtil; using lib::time::Time; using lib::time::TimeVar; diff --git a/src/stage/widget/timeline/timeline-ruler.hpp b/src/stage/widget/timeline/timeline-ruler.hpp index 2f039d1ed..03847269e 100644 --- a/src/stage/widget/timeline/timeline-ruler.hpp +++ b/src/stage/widget/timeline/timeline-ruler.hpp @@ -54,7 +54,7 @@ namespace widget { : public Gtk::DrawingArea { public: - TimelineRuler (gui::widget::TimelineWidget& timeline_widget); + TimelineRuler (stage::widget::TimelineWidget& timeline_widget); /** * Sets offset of the mouse chevron @@ -235,7 +235,7 @@ namespace widget { /** * The owner widget */ - gui::widget::TimelineWidget &timelineWidget; + stage::widget::TimelineWidget &timelineWidget; /** * the currently active timeline state object diff --git a/src/stage/widget/timeline/timeline-tool.cpp b/src/stage/widget/timeline/timeline-tool.cpp index 1dcc9fe0c..47f6f3a3c 100644 --- a/src/stage/widget/timeline/timeline-tool.cpp +++ b/src/stage/widget/timeline/timeline-tool.cpp @@ -89,10 +89,10 @@ namespace timeline { } - gui::widget::TimelineWidget& + stage::widget::TimelineWidget& Tool::get_timeline_widget() const { - gui::widget::TimelineWidget &timeline_widget = + stage::widget::TimelineWidget &timeline_widget = timelineBody.timelineWidget; return timeline_widget; } diff --git a/src/stage/widget/timeline/timeline-tool.hpp b/src/stage/widget/timeline/timeline-tool.hpp index 3ea2ef271..7883f9dae 100644 --- a/src/stage/widget/timeline/timeline-tool.hpp +++ b/src/stage/widget/timeline/timeline-tool.hpp @@ -126,7 +126,7 @@ namespace timeline { * Helper function which retrieves the pointer to owner timeline * widget object, which is the owner of the timeline body. */ - gui::widget::TimelineWidget &get_timeline_widget() const; + stage::widget::TimelineWidget &get_timeline_widget() const; /** * Helper function which retrieves the rectangle of the timeline diff --git a/src/stage/widget/video-display-widget.cpp b/src/stage/widget/video-display-widget.cpp index 972ecf5ef..4955e6ffc 100644 --- a/src/stage/widget/video-display-widget.cpp +++ b/src/stage/widget/video-display-widget.cpp @@ -95,4 +95,4 @@ namespace widget { } -}}// gui::widget +}}// stage::widget diff --git a/src/stage/widget/video-display-widget.hpp b/src/stage/widget/video-display-widget.hpp index 880c78b91..1e4217af6 100644 --- a/src/stage/widget/video-display-widget.hpp +++ b/src/stage/widget/video-display-widget.hpp @@ -69,5 +69,5 @@ namespace widget { }; -}}// gui::widget +}}// stage::widget #endif /*STAGE_WIDGET_VIDEO_DISPLAY_WIDGET_H*/ diff --git a/src/steam/asset.hpp b/src/steam/asset.hpp index 3a4171a45..b125d7e3b 100644 --- a/src/steam/asset.hpp +++ b/src/steam/asset.hpp @@ -356,11 +356,11 @@ namespace asset { namespace proc_interface { - using proc::asset::Asset; - using proc::asset::Category; - using proc::asset::ID; - using proc::asset::IDA; - using proc::asset::PAsset; + using steam::asset::Asset; + using steam::asset::Category; + using steam::asset::ID; + using steam::asset::IDA; + using steam::asset::PAsset; } #endif diff --git a/src/steam/asset/media.hpp b/src/steam/asset/media.hpp index 6c420a336..e75fcf945 100644 --- a/src/steam/asset/media.hpp +++ b/src/steam/asset/media.hpp @@ -76,8 +76,8 @@ namespace asset { public: using PMedia = lib::P; - using PClipAsset = lib::P; - using PProcPatt = lib::P; + using PClipAsset = lib::P; + using PProcPatt = lib::P; using PClip = mobject::Placement; @@ -123,7 +123,7 @@ namespace asset { * @return pointer to parent, or `null` */ virtual PMedia checkCompound () const; - friend class proc::asset::Clip; ////////////////////////TODO better interface!!! + friend class steam::asset::Clip; ////////////////////////TODO better interface!!! }; diff --git a/src/steam/asset/meta/error-log.hpp b/src/steam/asset/meta/error-log.hpp index d46add0ef..6b12fc159 100644 --- a/src/steam/asset/meta/error-log.hpp +++ b/src/steam/asset/meta/error-log.hpp @@ -28,11 +28,11 @@ ** in order to mark the corresponding receiver widget in the UI. The idea is eventually ** to persist relevant messages, filtering them out as time passes. Such an incident log ** would be part of the session model, thus replicating its contents into the corresponding - ** gui::widget::ErrorLogView -- which displays notifications without blocking the UI. + ** stage::widget::ErrorLogView -- which displays notifications without blocking the UI. ** ** @see MetaFactory creating concrete asset::Meta instances - ** @see gui::ctrl::NotificationHub corresponding UI controller - ** @see gui::interact::Wizard information service in the UI + ** @see stage::ctrl::NotificationHub corresponding UI controller + ** @see stage::interact::Wizard information service in the UI ** */ diff --git a/src/steam/asset/struct-factory-impl.hpp b/src/steam/asset/struct-factory-impl.hpp index 75441ecac..d3cc8b714 100644 --- a/src/steam/asset/struct-factory-impl.hpp +++ b/src/steam/asset/struct-factory-impl.hpp @@ -73,14 +73,14 @@ namespace asset { using lumiera::query::LERR_(CAPABILITY_QUERY); using lib::query::extractID; - using proc::mobject::Session; - using proc::mobject::MObject; - using proc::mobject::session::Scope; - using proc::mobject::session::match_specificFork; - using proc::mobject::session::RBinding; - using proc::mobject::session::ForkID; - using proc::mobject::session::RFork; - using proc::mobject::session::Fork; + using steam::mobject::Session; + using steam::mobject::MObject; + using steam::mobject::session::Scope; + using steam::mobject::session::match_specificFork; + using steam::mobject::session::RBinding; + using steam::mobject::session::ForkID; + using steam::mobject::session::RFork; + using steam::mobject::session::Fork; using idi::StructTraits; diff --git a/src/steam/asset/struct-scheme.hpp b/src/steam/asset/struct-scheme.hpp index 9bc335a44..d997066cf 100644 --- a/src/steam/asset/struct-scheme.hpp +++ b/src/steam/asset/struct-scheme.hpp @@ -104,7 +104,7 @@ namespace asset{ static Symbol catFolder() { return "pipes";} static Symbol idSymbol() { return "pipe"; } }; - template<> struct StructTraits + template<> struct StructTraits { static Symbol namePrefix() { return "type"; } static Symbol catFolder() { return "stream-types";} diff --git a/src/steam/asset/struct.cpp b/src/steam/asset/struct.cpp index f7a69925f..3037f08b1 100644 --- a/src/steam/asset/struct.cpp +++ b/src/steam/asset/struct.cpp @@ -54,7 +54,7 @@ using util::_Fmt; using lib::Symbol; using lib::query::normaliseID; using lumiera::query::QueryHandler; -using proc::ConfigResolver; +using steam::ConfigResolver; using util::contains; diff --git a/src/steam/assetmanager.hpp b/src/steam/assetmanager.hpp index 7c7e6896f..9bf8ac8b6 100644 --- a/src/steam/assetmanager.hpp +++ b/src/steam/assetmanager.hpp @@ -140,7 +140,7 @@ namespace asset { namespace proc_interface { - using proc::asset::AssetManager; + using steam::asset::AssetManager; } #endif diff --git a/src/steam/cmd/meta-cmd.cpp b/src/steam/cmd/meta-cmd.cpp index 760bd2b59..913f507cc 100644 --- a/src/steam/cmd/meta-cmd.cpp +++ b/src/steam/cmd/meta-cmd.cpp @@ -50,13 +50,13 @@ #include using lib::hash::LuidH; -using gui::ID; -using gui::NOTE_INFO; -using gui::NOTE_WARN; -using gui::NOTE_ERROR; -using gui::NotifyLevel; -using gui::MARK_expand; -using gui::GuiNotification; +using stage::ID; +using stage::NOTE_INFO; +using stage::NOTE_WARN; +using stage::NOTE_ERROR; +using stage::NotifyLevel; +using stage::MARK_expand; +using stage::GuiNotification; using lib::diff::GenNode; //using util::cStr; using util::_Fmt; //////////////////////////////////////////////////////////////TICKET #1140 : include needed temporarily @@ -172,7 +172,7 @@ COMMAND_DEFINITION (test_meta_markError) { def.operation ([](string message) { - ID errorLogID = gui::interact::Wizard::getErrorLogID(); + ID errorLogID = stage::interact::Wizard::getErrorLogID(); GuiNotification::facade().markError (errorLogID, message); }) .captureUndo ([](string message) -> string @@ -193,7 +193,7 @@ COMMAND_DEFINITION (test_meta_markNote) { def.operation ([](string message) { - ID errorLogID = gui::interact::Wizard::getErrorLogID(); + ID errorLogID = stage::interact::Wizard::getErrorLogID(); GuiNotification::facade().markNote (errorLogID, message); }) .captureUndo ([](string message) -> string @@ -214,7 +214,7 @@ COMMAND_DEFINITION (test_meta_markAction) { def.operation ([](string actionID, string message) { - ID errorLogID = gui::interact::Wizard::getErrorLogID(); + ID errorLogID = stage::interact::Wizard::getErrorLogID(); GuiNotification::facade().mark (errorLogID ,actionID==MARK_expand? GenNode{actionID, isYes(message)} : GenNode{actionID, message}); diff --git a/src/steam/config-resolver.cpp b/src/steam/config-resolver.cpp index 7462b2240..86c854f2c 100644 --- a/src/steam/config-resolver.cpp +++ b/src/steam/config-resolver.cpp @@ -92,16 +92,16 @@ namespace steam { namespace lumiera{ namespace query { - using proc::asset::Pipe; - using proc::asset::PPipe; - using proc::asset::ProcPatt; - using proc::asset::PProcPatt; - using proc::asset::Timeline; - using proc::asset::PTimeline; - using proc::asset::Sequence; - using proc::asset::PSequence; + using steam::asset::Pipe; + using steam::asset::PPipe; + using steam::asset::ProcPatt; + using steam::asset::PProcPatt; + using steam::asset::Timeline; + using steam::asset::PTimeline; + using steam::asset::Sequence; + using steam::asset::PSequence; - using proc::mobject::session::Fork; + using steam::mobject::session::Fork; using PFork = lib::P; template PPipe DefsManager::operator() (Query const&); diff --git a/src/steam/config-resolver.hpp b/src/steam/config-resolver.hpp index 8ff4d1787..d405808a5 100644 --- a/src/steam/config-resolver.hpp +++ b/src/steam/config-resolver.hpp @@ -26,7 +26,7 @@ ** Definition of the concrete frontend for rule based configuration within the session. ** ** @remarks This code will act as a hub to pull in, instrument and activate a lot of further code. - ** All the types mentioned in the proc::InterfaceTypes typelist will be prepared to be used + ** All the types mentioned in the steam::InterfaceTypes typelist will be prepared to be used ** in rules based setup and configuration; this definition will drive the generation of ** all the necessary bindings and registration entries to make this work. This is in ** accordance with the principle of *generic programming*: Instead of making things @@ -70,11 +70,11 @@ namespace steam { * the list of all concrete types participating in the * rule based config query system */ - typedef lib::meta::Types < proc::mobject::session::Fork - , proc::asset::Pipe - , const proc::asset::ProcPatt - , proc::asset::Timeline - , proc::asset::Sequence + typedef lib::meta::Types < steam::mobject::session::Fork + , steam::asset::Pipe + , const steam::asset::ProcPatt + , steam::asset::Timeline + , steam::asset::Sequence > ::List InterfaceTypes; diff --git a/src/steam/control/command-instance-manager.hpp b/src/steam/control/command-instance-manager.hpp index ed4534ef6..276262cae 100644 --- a/src/steam/control/command-instance-manager.hpp +++ b/src/steam/control/command-instance-manager.hpp @@ -89,7 +89,7 @@ namespace control { * (i.e. there is no registration of a command under that instanceID in the global CommandRegistry). * When done with the parametrisation, by calling #dispatch, this anonymous instance will be handed * over to the [Dispatcher](\ref CommandDispatch) (installed on construction). Typically, this will in fact - * be the proc::control::ProcDispatcher, which runs in a dedicated thread ("session loop thread") and + * be the steam::control::ProcDispatcher, which runs in a dedicated thread ("session loop thread") and * maintains a queue of commands to be dispatched towards the current session. Since Command is a smart * handle, the enqueued instance will stay alive until execution and then go out of scope. But, after * #dispatch, it is no longer accessible from the CommandInstanceManger, and while it is still waiting diff --git a/src/steam/control/command-setup.cpp b/src/steam/control/command-setup.cpp index d66cd65b7..a999a84aa 100644 --- a/src/steam/control/command-setup.cpp +++ b/src/steam/control/command-setup.cpp @@ -107,7 +107,7 @@ namespace control { * The assumption is that this _definition closure_ will care to define the command, * state capturing and undo operations for the command definition in question. Thus, * the result of invoking this closure will be to store a complete command prototype - * into the proc::control::CommandRegistry. + * into the steam::control::CommandRegistry. * @note this operation works by side-effect; the given argument is fed into a hidden static * queue, but not stored within the object instance. * @warning invoking this assignment _several times on the same CommandSetup object_ will likely diff --git a/src/steam/control/looper.hpp b/src/steam/control/looper.hpp index 03ba652be..135430348 100644 --- a/src/steam/control/looper.hpp +++ b/src/steam/control/looper.hpp @@ -63,7 +63,7 @@ namespace control { using lib::time::TimeVar; using lib::time::Offset; using lib::time::Duration; - using backend::RealClock; + using vault::RealClock; namespace { /** diff --git a/src/steam/control/proc-dispatcher.cpp b/src/steam/control/proc-dispatcher.cpp index 3457b4cd8..4f9489d57 100644 --- a/src/steam/control/proc-dispatcher.cpp +++ b/src/steam/control/proc-dispatcher.cpp @@ -96,7 +96,7 @@ using lib::Sync; using lib::RecursiveLock_Waitable; -using backend::Thread; +using vault::Thread; using std::unique_ptr; namespace steam { diff --git a/src/steam/control/proc-dispatcher.hpp b/src/steam/control/proc-dispatcher.hpp index a4ba98098..1e79b5c2c 100644 --- a/src/steam/control/proc-dispatcher.hpp +++ b/src/steam/control/proc-dispatcher.hpp @@ -79,7 +79,7 @@ namespace control { * class is the _»session loop thread«_ to perform any session mutation * commands and to operate the Builder, which translates the session * contents into a render nodes network. Also embedded herein is - * the implementation of proc::control::SessionCommandService + * the implementation of steam::control::SessionCommandService */ class ProcDispatcher : public lib::Sync<> diff --git a/src/steam/control/session-command-interface-proxy.cpp b/src/steam/control/session-command-interface-proxy.cpp index b3b29eb63..d9d625bf9 100644 --- a/src/steam/control/session-command-interface-proxy.cpp +++ b/src/steam/control/session-command-interface-proxy.cpp @@ -23,8 +23,8 @@ /** @file session-command-interface-proxy.cpp - ** Interface-Proxy for the proc::control::SessionCommand facade. - ** The purpose is to define a proxy implementation of proc::control::SessionCommand, in order to + ** Interface-Proxy for the steam::control::SessionCommand facade. + ** The purpose is to define a proxy implementation of steam::control::SessionCommand, in order to ** redirect any calls through the associated C Language Interface "lumieraorg_SessionCommand" ** ** @see session-command-facade.hpp @@ -48,7 +48,7 @@ namespace facade { /* ==================== SessionCommand =================================== */ using Interface = LUMIERA_INTERFACE_INAME(lumieraorg_SessionCommand, 0); - using Facade = proc::control::SessionCommand; + using Facade = steam::control::SessionCommand; using IHandle = InstanceHandle; diff --git a/src/steam/control/session-command-service.hpp b/src/steam/control/session-command-service.hpp index be111a461..ac9661b31 100644 --- a/src/steam/control/session-command-service.hpp +++ b/src/steam/control/session-command-service.hpp @@ -29,7 +29,7 @@ ** an UNDO function. ** ** This service is the implementation of a layer separation facade interface. Clients should use - ** proc::control::SessionCommand::facade to access this service. This header defines the interface + ** steam::control::SessionCommand::facade to access this service. This header defines the interface ** used to _provide_ this service, not to access it. ** ** @see session-command-facade.h diff --git a/src/steam/control/stypemanager.cpp b/src/steam/control/stypemanager.cpp index 4ef816aad..d7be4e9c0 100644 --- a/src/steam/control/stypemanager.cpp +++ b/src/steam/control/stypemanager.cpp @@ -127,5 +127,5 @@ namespace control { void lumiera_StreamType_registerInitFunction (void setupFun(void)) { - lumiera::LifecycleHook (proc::control::ON_STREAMTYPES_RESET, setupFun); + lumiera::LifecycleHook (steam::control::ON_STREAMTYPES_RESET, setupFun); } diff --git a/src/steam/control/stypemanager.hpp b/src/steam/control/stypemanager.hpp index d710b49e8..e94da8bd9 100644 --- a/src/steam/control/stypemanager.hpp +++ b/src/steam/control/stypemanager.hpp @@ -115,7 +115,7 @@ namespace control { namespace proc_interface { - using proc::control::STypeManager; + using steam::control::STypeManager; } // namespace proc_interface diff --git a/src/steam/engine/calc-plan-continuation.hpp b/src/steam/engine/calc-plan-continuation.hpp index e37603093..6a67ae90a 100644 --- a/src/steam/engine/calc-plan-continuation.hpp +++ b/src/steam/engine/calc-plan-continuation.hpp @@ -48,8 +48,8 @@ namespace steam { namespace engine { // using std::function; - using backend::engine::JobParameter; - using backend::engine::JobClosure; + using vault::engine::JobParameter; + using vault::engine::JobClosure; using mobject::ModelPort; // using lib::time::TimeSpan; // using lib::time::FSecs; diff --git a/src/steam/engine/engine-diagnostics.hpp b/src/steam/engine/engine-diagnostics.hpp index 140b4dd61..46287decb 100644 --- a/src/steam/engine/engine-diagnostics.hpp +++ b/src/steam/engine/engine-diagnostics.hpp @@ -61,7 +61,7 @@ namespace engine{ // using lumiera::Subsys; // using lumiera::Display; // using lumiera::DummyPlayer; - using proc::play::Timings; + using steam::play::Timings; diff --git a/src/steam/engine/engine-service-mock.hpp b/src/steam/engine/engine-service-mock.hpp index fc9fe0daf..b5f48fe45 100644 --- a/src/steam/engine/engine-service-mock.hpp +++ b/src/steam/engine/engine-service-mock.hpp @@ -29,7 +29,7 @@ ** @todo 1/2012 until the real render engine is usable, this mock implementation ** will stand-in, allowing us to develop the other parts of the play/render subsystem. ** - ** @see proc::engine::EngineService "the real thing" + ** @see steam::engine::EngineService "the real thing" ** @see render-configurator.cpp (activating the mock or the real engine) ** @see DummyPlayConnection ** @see EngineInterface_test @@ -64,7 +64,7 @@ namespace engine{ // using lumiera::Display; // using lumiera::DummyPlayer; using mobject::ModelPort; - using proc::play::Timings; + using steam::play::Timings; typedef EngineService::Quality Quality; diff --git a/src/steam/engine/engine-service.hpp b/src/steam/engine/engine-service.hpp index bd9207564..10dbdfd56 100644 --- a/src/steam/engine/engine-service.hpp +++ b/src/steam/engine/engine-service.hpp @@ -42,8 +42,8 @@ ** @todo draft from 2013, stalled, but still relevant and to be continued eventually ** @see EngineInterface_test ** @see CalcStream_test - ** @see proc::play::PlayerService - ** @see backend::engine::EngineConfig + ** @see steam::play::PlayerService + ** @see vault::engine::EngineConfig ** */ @@ -78,9 +78,9 @@ namespace engine{ // using lumiera::DummyPlayer; // using std::function; using mobject::ModelPort; - using proc::play::Timings; + using steam::play::Timings; - typedef proc::play::OutputSlot::Allocation OutputConnection; + typedef steam::play::OutputSlot::Allocation OutputConnection; diff --git a/src/steam/engine/job-planning.hpp b/src/steam/engine/job-planning.hpp index 615f75d30..c1b0e2115 100644 --- a/src/steam/engine/job-planning.hpp +++ b/src/steam/engine/job-planning.hpp @@ -34,7 +34,7 @@ ** - JobPlanningSequence is the entry point for client code: it allows to generate a sequence of jobs ** - JobPlanning is a view on top of all the collected planning information for a single job ** - PlanningState is an iterator, successively exposing a sequence of JobPlanning views - ** - proc::engine::expandPrerequisites(JobPlanning const&) is the operation to explore further prerequisite Jobs recursively + ** - steam::engine::expandPrerequisites(JobPlanning const&) is the operation to explore further prerequisite Jobs recursively ** - PlanningStepGenerator yields the underlying "master beat": a sequence of frame locations to be planned ** ** ## how the PlanningState (sequence) is advanced diff --git a/src/steam/engine/job-ticket.cpp b/src/steam/engine/job-ticket.cpp index 122d2b20d..3856b585c 100644 --- a/src/steam/engine/job-ticket.cpp +++ b/src/steam/engine/job-ticket.cpp @@ -43,8 +43,8 @@ namespace engine { // using mobject::Placement; // using mobject::session::Effect; -using backend::engine::JobParameter; -using backend::engine::JobClosure; +using vault::engine::JobParameter; +using vault::engine::JobClosure; diff --git a/src/steam/engine/job-ticket.hpp b/src/steam/engine/job-ticket.hpp index c80fb1465..493aa72f5 100644 --- a/src/steam/engine/job-ticket.hpp +++ b/src/steam/engine/job-ticket.hpp @@ -53,7 +53,7 @@ namespace engine { //using lib::time::Duration; //using lib::time::FSecs; //using lib::time::Time; -using backend::engine::Job; +using vault::engine::Job; using lib::LinkedElements; using lib::OrientationIndicator; using util::isnil; diff --git a/src/steam/engine/nodewiring-config.hpp b/src/steam/engine/nodewiring-config.hpp index 8eaff2422..ceeb2102a 100644 --- a/src/steam/engine/nodewiring-config.hpp +++ b/src/steam/engine/nodewiring-config.hpp @@ -40,7 +40,7 @@ ** ProcNode subclasses), but parts of this configuration assembly is done already at ** compile time, allowing for additional checks by typing and for possible optimisation. ** - ** @see proc::engine::config::Strategy + ** @see steam::engine::config::Strategy ** @see nodewiring.hpp ** @see configflags.hpp ** @see config-flags-test.cpp diff --git a/src/steam/engine/nodewiring-def.hpp b/src/steam/engine/nodewiring-def.hpp index 341d40a41..996405cd2 100644 --- a/src/steam/engine/nodewiring-def.hpp +++ b/src/steam/engine/nodewiring-def.hpp @@ -29,7 +29,7 @@ ** the desired operation mode of this node need to be available. Thus we use this temporary ** information record to assemble all these pieces of information. ** - ** @see proc::engine::NodeFactory + ** @see steam::engine::NodeFactory ** @see nodewiring.hpp ** @see node-basic-test.cpp ** diff --git a/src/steam/engine/stateproxy.hpp b/src/steam/engine/stateproxy.hpp index bbc3ff06f..4b5438cfd 100644 --- a/src/steam/engine/stateproxy.hpp +++ b/src/steam/engine/stateproxy.hpp @@ -28,7 +28,7 @@ ** into this recursive evaluation, beyond the data in the local call stack. Such ** additional statefull dependencies are problematic (regarding concurrency and ** throughput) and are thus abstracted from the actual processing operations - ** with the help of the proc::engine::State interface + ** with the help of the steam::engine::State interface ** @todo unfinished draft from 2009 regarding the render process */ diff --git a/src/steam/engine/time-anchor.hpp b/src/steam/engine/time-anchor.hpp index ee10c9306..19f47735c 100644 --- a/src/steam/engine/time-anchor.hpp +++ b/src/steam/engine/time-anchor.hpp @@ -47,7 +47,7 @@ namespace steam { namespace engine { - using backend::RealClock; + using vault::RealClock; using lib::time::Offset; using lib::time::Duration; using lib::time::FrameCnt; diff --git a/src/steam/engine/worker/dummy-image-generator.hpp b/src/steam/engine/worker/dummy-image-generator.hpp index dee95236c..07c2ff7f9 100644 --- a/src/steam/engine/worker/dummy-image-generator.hpp +++ b/src/steam/engine/worker/dummy-image-generator.hpp @@ -30,8 +30,8 @@ ** dummy playback service. ** ** @todo obsolete since 2010, can be removed once we have a real player in the UI - ** @see gui::controller::PlaybackController - ** @see proc::play::DummyPlayerService + ** @see stage::controller::PlaybackController + ** @see steam::play::DummyPlayerService ** */ diff --git a/src/steam/engine/worker/dummy-tick.hpp b/src/steam/engine/worker/dummy-tick.hpp index a33d72a9f..1a3c43d62 100644 --- a/src/steam/engine/worker/dummy-tick.hpp +++ b/src/steam/engine/worker/dummy-tick.hpp @@ -29,7 +29,7 @@ ** setup, used to verify the construction of engine components. As an integration ** test, we build a "dummy player", delivering some test data frames to the Gui. ** - ** @see proc::play::DummyPlayerService + ** @see steam::play::DummyPlayerService ** */ @@ -58,7 +58,7 @@ namespace node { * with adjustable frequency. Quick'n dirty implementation! */ class DummyTick - : backend::ThreadJoinable + : vault::ThreadJoinable { typedef function Tick; volatile uint timespan_; diff --git a/src/steam/engine/worker/tick-service.hpp b/src/steam/engine/worker/tick-service.hpp index 82f085bad..66bfe0096 100644 --- a/src/steam/engine/worker/tick-service.hpp +++ b/src/steam/engine/worker/tick-service.hpp @@ -29,7 +29,7 @@ ** setup, used to verify the construction of engine components. As an integration ** test, we build a "dummy player", delivering some test data frames to the Gui. ** - ** @see proc::play::DummyPlayerService + ** @see steam::play::DummyPlayerService ** */ @@ -60,7 +60,7 @@ namespace node { * with adjustable frequency. Quick'n dirty implementation! */ class TickService - : backend::ThreadJoinable + : vault::ThreadJoinable { typedef function Tick; volatile uint timespan_; diff --git a/src/steam/facade.cpp b/src/steam/facade.cpp index ff30d723e..97b3410d6 100644 --- a/src/steam/facade.cpp +++ b/src/steam/facade.cpp @@ -33,7 +33,7 @@ ** large scale building blocks of the whole application to be started and terminated. ** Typically this entails to create a dedicated thread to manage the top level concerns ** for the given subsystem, and to create registration and services for public access: - ** - to operate on the session, use the proc::control::SessionCommand facade + ** - to operate on the session, use the steam::control::SessionCommand facade ** - playback and render operations can be operated by the lumiera::Play facade ** ** @see ProcDispatcher @@ -58,7 +58,7 @@ namespace steam { using std::unique_ptr; using lumiera::Subsys; using lumiera::Option; - using proc::control::ProcDispatcher; + using steam::control::ProcDispatcher; class SessionSubsystem diff --git a/src/steam/mobject/output-designation.cpp b/src/steam/mobject/output-designation.cpp index 5d681deed..97409585b 100644 --- a/src/steam/mobject/output-designation.cpp +++ b/src/steam/mobject/output-designation.cpp @@ -55,7 +55,7 @@ using lumiera::Symbol; using lumiera::query::QueryHandler; using lib::query::removeTerm; using lib::query::extractID; -using proc::ConfigResolver; +using steam::ConfigResolver; using lib::HashVal; using util::uNum; diff --git a/src/steam/mobject/session/dummy-session-connection.cpp b/src/steam/mobject/session/dummy-session-connection.cpp index b4c26dfdc..02a5e0c34 100644 --- a/src/steam/mobject/session/dummy-session-connection.cpp +++ b/src/steam/mobject/session/dummy-session-connection.cpp @@ -83,7 +83,7 @@ namespace session { { return MakeRec() .set(MakeRec() - .type (string{gui::TYPE_Fork}) + .type (string{stage::TYPE_Fork}) .genNode(forkRootID) ) .genNode(baseID); @@ -108,9 +108,9 @@ namespace session { MutationMessage DummySessionConnection::fabricateSeq1 (string baseID) { - const RandID forkRootID{gui::ATTR_fork}; + const RandID forkRootID{stage::ATTR_fork}; const GenNode timeline = emptyTimeline (baseID, forkRootID) - , rootTrackName = GenNode{string{gui::ATTR_name}, "Track-"+baseID} + , rootTrackName = GenNode{string{stage::ATTR_name}, "Track-"+baseID} , FORK_ROOT = MakeRec().genNode(forkRootID) ; @@ -136,16 +136,16 @@ namespace session { namespace cmd { using lib::hash::LuidH; - using gui::ID; - using gui::NOTE_INFO; - using gui::NOTE_WARN; - using gui::NOTE_ERROR; -// using gui::NotifyLevel; -// using gui::MARK_expand; - using gui::GuiNotification; + using stage::ID; + using stage::NOTE_INFO; + using stage::NOTE_WARN; + using stage::NOTE_ERROR; +// using stage::NotifyLevel; +// using stage::MARK_expand; + using stage::GuiNotification; // using util::isYes; - namespace session = proc::mobject::session; + namespace session = steam::mobject::session; using DummySess = session::DummySessionConnection; diff --git a/src/steam/mobject/session/dummy-session-connection.hpp b/src/steam/mobject/session/dummy-session-connection.hpp index d99601231..18dce8545 100644 --- a/src/steam/mobject/session/dummy-session-connection.hpp +++ b/src/steam/mobject/session/dummy-session-connection.hpp @@ -84,9 +84,9 @@ namespace session { * @note readily-available singleton to enact prototypical behaviour as appropriate. * * @see DummySessionConnection_test - * @see gui::interact::InteractionDirector::buildMutator - * @see gui::interact::InteractionDirector::injectTimeline - * @see gui::timeline::TimelineController + * @see stage::interact::InteractionDirector::buildMutator + * @see stage::interact::InteractionDirector::injectTimeline + * @see stage::timeline::TimelineController */ class DummySessionConnection : lib::diff::TreeDiffLanguage diff --git a/src/steam/mobject/session/placement-index.hpp b/src/steam/mobject/session/placement-index.hpp index e145fde5a..a5bf47d29 100644 --- a/src/steam/mobject/session/placement-index.hpp +++ b/src/steam/mobject/session/placement-index.hpp @@ -122,10 +122,10 @@ namespace std { /////////////////////////////////////////////////////////////////////////TICKET #722 : should provide a generic bridge to use hash_value template<> - struct hash + struct hash { size_t - operator() (proc::mobject::PlacementMO::ID const& val) const noexcept + operator() (steam::mobject::PlacementMO::ID const& val) const noexcept { return hash_value(val); } diff --git a/src/steam/mobject/session/query/fake-configrules.hpp b/src/steam/mobject/session/query/fake-configrules.hpp index 7208f7500..3df2363ef 100644 --- a/src/steam/mobject/session/query/fake-configrules.hpp +++ b/src/steam/mobject/session/query/fake-configrules.hpp @@ -64,12 +64,12 @@ namespace mobject { namespace session { namespace query { - namespace asset = proc::asset; + namespace asset = steam::asset; using asset::Pipe; using asset::ProcPatt; using asset::PProcPatt; - using proc::mobject::Session; + using steam::mobject::Session; using lib::meta::InstantiateChained; using lib::P; @@ -128,7 +128,7 @@ namespace session { * in automatically managed heap memory. */ class MockTable - : public proc::ConfigResolver + : public steam::ConfigResolver { typedef std::map Tab; @@ -284,7 +284,7 @@ namespace session { * values for some types of interest for testing and debugging. */ class MockConfigRules - : public InstantiateChained < proc::InterfaceTypes + : public InstantiateChained < steam::InterfaceTypes , LookupPreconfigured // building block used for each of the types , MockTable // for implementing the base class (interface) > diff --git a/src/steam/mobject/session/scope-path.hpp b/src/steam/mobject/session/scope-path.hpp index ddce6babc..7950eb489 100644 --- a/src/steam/mobject/session/scope-path.hpp +++ b/src/steam/mobject/session/scope-path.hpp @@ -98,7 +98,7 @@ namespace lib { namespace meta{ - using proc::mobject::session::Scope; + using steam::mobject::session::Scope; /** * this explicit specialisation allows to build a RangeIter diff --git a/src/steam/play/dummy-play-connection.hpp b/src/steam/play/dummy-play-connection.hpp index 413235fca..286128ceb 100644 --- a/src/steam/play/dummy-play-connection.hpp +++ b/src/steam/play/dummy-play-connection.hpp @@ -70,7 +70,7 @@ ** able to address this topic again. At the moment, the UI-Session connection is more urgent. ** ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ diff --git a/src/steam/play/dummy-player-interface-proxy.cpp b/src/steam/play/dummy-player-interface-proxy.cpp index 411cd3a3f..32b667255 100644 --- a/src/steam/play/dummy-player-interface-proxy.cpp +++ b/src/steam/play/dummy-player-interface-proxy.cpp @@ -81,7 +81,7 @@ namespace lumiera { { //----Proxy-Implementation-of-DummyPlayer-------- typedef lumiera::DummyPlayer::Process Process; - typedef proc::play::ProcessImpl ProcessImpl; + typedef steam::play::ProcessImpl ProcessImpl; /** @note as an optimisation we hand out a direct reference * to the implementing process object. While this ref could diff --git a/src/steam/play/dummy-player-service.cpp b/src/steam/play/dummy-player-service.cpp index de6379467..b2e60dda0 100644 --- a/src/steam/play/dummy-player-service.cpp +++ b/src/steam/play/dummy-player-service.cpp @@ -378,7 +378,7 @@ namespace lumiera { lumiera::Subsys& DummyPlayer::getDescriptor() { - return proc::play::theDummyPlayerDescriptor(); + return steam::play::theDummyPlayerDescriptor(); } diff --git a/src/steam/play/dummy-player-service.hpp b/src/steam/play/dummy-player-service.hpp index 9da754f39..a457ee3c6 100644 --- a/src/steam/play/dummy-player-service.hpp +++ b/src/steam/play/dummy-player-service.hpp @@ -29,11 +29,11 @@ ** it uses an output handle (functor) to push the generated frames up. ** ** This service is the implementation of a layer separation facade interface. Clients should use - ** proc::play::DummyPlayer#facade to access this service. This header defines the interface used + ** steam::play::DummyPlayer#facade to access this service. This header defines the interface used ** to \em provide this service, not to access it. ** ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ @@ -63,8 +63,8 @@ namespace steam { using lumiera::Display; using lumiera::DummyPlayer; - using proc::node::DummyImageGenerator; - using proc::node::TickService; + using steam::node::DummyImageGenerator; + using steam::node::TickService; diff --git a/src/steam/play/output-director.cpp b/src/steam/play/output-director.cpp index a1b240f9a..d5c310015 100644 --- a/src/steam/play/output-director.cpp +++ b/src/steam/play/output-director.cpp @@ -31,7 +31,7 @@ #include "steam/play/output-director.hpp" #include "vault/thread-wrapper.hpp" -using backend::Thread; +using vault::Thread; namespace steam { diff --git a/src/steam/play/output-slot-connection.hpp b/src/steam/play/output-slot-connection.hpp index 054f9ade0..fffbcc11e 100644 --- a/src/steam/play/output-slot-connection.hpp +++ b/src/steam/play/output-slot-connection.hpp @@ -60,8 +60,8 @@ namespace steam { namespace play { - using proc::engine::BuffHandle; -//using proc::engine::BufferProvider; + using steam::engine::BuffHandle; +//using steam::engine::BufferProvider; //using lib::time::Time; //using std::string; using lib::iter_stl::eachElm; diff --git a/src/steam/play/output-slot.hpp b/src/steam/play/output-slot.hpp index 26b50a82d..60aa66352 100644 --- a/src/steam/play/output-slot.hpp +++ b/src/steam/play/output-slot.hpp @@ -80,8 +80,8 @@ namespace steam { namespace play { - using proc::engine::BuffHandle; - using proc::engine::BufferProvider; + using steam::engine::BuffHandle; + using steam::engine::BufferProvider; using lib::time::FrameCnt; using lib::time::TimeValue; using lib::time::Time; diff --git a/src/steam/play/play-controller.cpp b/src/steam/play/play-controller.cpp index 7df89704e..e05e568a4 100644 --- a/src/steam/play/play-controller.cpp +++ b/src/steam/play/play-controller.cpp @@ -31,7 +31,7 @@ ** situations ** ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ @@ -48,7 +48,7 @@ namespace lumiera { using lib::time::Time; using lib::time::Duration; using lib::time::TimeSpan; - using proc::play::PlayProcess; + using steam::play::PlayProcess; diff --git a/src/steam/play/play-controller.hpp b/src/steam/play/play-controller.hpp index bc8ce4853..79cc1bbbc 100644 --- a/src/steam/play/play-controller.hpp +++ b/src/steam/play/play-controller.hpp @@ -24,7 +24,7 @@ ** Functionality for driving and controlling an ongoing playback or render. ** ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ diff --git a/src/steam/play/play-process.hpp b/src/steam/play/play-process.hpp index 420f1683d..425cffec5 100644 --- a/src/steam/play/play-process.hpp +++ b/src/steam/play/play-process.hpp @@ -43,7 +43,7 @@ ** to reconfigure the ongoing or planned calculations. ** ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ @@ -75,7 +75,7 @@ namespace play { // using lumiera::Display; // using lumiera::DummyPlayer; using util::isnil; - using proc::mobject::ModelPort; + using steam::mobject::ModelPort; using std::function; typedef lib::IterSource::iterator ModelPorts; diff --git a/src/steam/play/render-configurator.hpp b/src/steam/play/render-configurator.hpp index 2c4c365ef..4daa1c0c9 100644 --- a/src/steam/play/render-configurator.hpp +++ b/src/steam/play/render-configurator.hpp @@ -62,9 +62,9 @@ namespace play { // using lumiera::DummyPlayer; // using util::isnil; using std::function; - using proc::mobject::ModelPort; + using steam::mobject::ModelPort; -// typedef proc::play::POutputManager POutputManager; +// typedef steam::play::POutputManager POutputManager; // typedef lib::IterSource::iterator ModelPorts; namespace error = lumiera::error; diff --git a/src/steam/play/sound/jack-output.hpp b/src/steam/play/sound/jack-output.hpp index 27e4077d4..b14a3478c 100644 --- a/src/steam/play/sound/jack-output.hpp +++ b/src/steam/play/sound/jack-output.hpp @@ -26,7 +26,7 @@ ** ** @see lumiera::Display ** @see lumiera::DummyPlayer - ** @see gui::PlaybackController usage example + ** @see stage::PlaybackController usage example */ diff --git a/src/steam/play/timings.cpp b/src/steam/play/timings.cpp index 70288bfe8..93b029022 100644 --- a/src/steam/play/timings.cpp +++ b/src/steam/play/timings.cpp @@ -40,7 +40,7 @@ namespace steam { namespace play { - using backend::engine::EngineConfig; + using vault::engine::EngineConfig; using lib::time::PQuant; using lib::time::Time; using lib::time::TimeVar; diff --git a/src/steam/play/timings.hpp b/src/steam/play/timings.hpp index 260cabaf0..729316519 100644 --- a/src/steam/play/timings.hpp +++ b/src/steam/play/timings.hpp @@ -132,7 +132,7 @@ namespace play { * @note since the Timings don't contain any information relating the * nominal time scale to wall clock time, this result is just * a relative offset, but expressed in real time scale values - * @see proc::engine::TimeAnchor for an absolutely anchored conversion + * @see steam::engine::TimeAnchor for an absolutely anchored conversion */ Offset getRealOffset (FrameCnt frameOffset) const; diff --git a/src/steam/state.hpp b/src/steam/state.hpp index 0b78c58af..537608062 100644 --- a/src/steam/state.hpp +++ b/src/steam/state.hpp @@ -121,7 +121,7 @@ namespace engine { namespace proc_interface { - using proc::engine::State; + using steam::engine::State; } // namespace proc_interface diff --git a/src/steam/streamtype.hpp b/src/steam/streamtype.hpp index 28002e672..aefcaa69c 100644 --- a/src/steam/streamtype.hpp +++ b/src/steam/streamtype.hpp @@ -196,7 +196,7 @@ namespace steam { namespace lumiera { - using proc::StreamType; + using steam::StreamType; } #endif /*STEAM_STREAMTYPE_H*/ diff --git a/src/vault/engine/engine-config.cpp b/src/vault/engine/engine-config.cpp index 7cf4dc6a2..eb3209638 100644 --- a/src/vault/engine/engine-config.cpp +++ b/src/vault/engine/engine-config.cpp @@ -85,7 +85,7 @@ namespace engine { }} // namespace vault::engine namespace { - using backend::engine::EngineConfig; + using vault::engine::EngineConfig; // any C adapter functions go here... diff --git a/src/vault/engine/job.cpp b/src/vault/engine/job.cpp index c9ff17087..61f97d609 100644 --- a/src/vault/engine/job.cpp +++ b/src/vault/engine/job.cpp @@ -146,7 +146,7 @@ namespace engine { }} // namespace vault::engine namespace { - using backend::engine::Job; + using vault::engine::Job; inline Job& forwardInvocation (lumiera_jobDefinition& jobDef) diff --git a/src/vault/engine/job.h b/src/vault/engine/job.h index 6e8ebbf3f..92215915e 100644 --- a/src/vault/engine/job.h +++ b/src/vault/engine/job.h @@ -36,7 +36,7 @@ ** to make these dependencies explicit and opaque for the scheduler. The actual ** job invocation is forwarded to a virtual function JobClosure#invokeJobOperation(JobParameter), ** which is defined "somewhere" in a subclass and remains opaque for the scheduler; - ** the \link proc::engine::Dispatcher frame dispatcher \endlink takes care to configure + ** the \link steam::engine::Dispatcher frame dispatcher \endlink takes care to configure ** each job descriptor with the correct pointer to a concrete closure prior to handing ** the job over to the scheduler. ** diff --git a/src/vault/media-access-facade.hpp b/src/vault/media-access-facade.hpp index 9100f5661..339ef7d53 100644 --- a/src/vault/media-access-facade.hpp +++ b/src/vault/media-access-facade.hpp @@ -150,9 +150,9 @@ namespace vault { namespace backend_interface { - using backend::MediaAccessFacade; - using backend::MediaDesc; - using backend::ChanDesc; + using vault::MediaAccessFacade; + using vault::MediaDesc; + using vault::ChanDesc; } // namespace backend_interface #endif diff --git a/src/vault/thread-wrapper.hpp b/src/vault/thread-wrapper.hpp index f8c71f13b..21d7f6ffb 100644 --- a/src/vault/thread-wrapper.hpp +++ b/src/vault/thread-wrapper.hpp @@ -28,7 +28,7 @@ ** which is relevant for scheduling render activities to make best use of parallelisation ** abilities of the given system. Typically, the upper layers should not have to deal much ** with thread handling, yet at some point there is the need to implement a self contained - ** action running within a dedicated thread. The backend::Thread class is a wrapper to + ** action running within a dedicated thread. The vault::Thread class is a wrapper to ** represent such an parallel action conveniently and safely; together with the object ** monitor, this allows to abstract away intricacies into self contained objects. ** diff --git a/tests/basics/call-queue-test.cpp b/tests/basics/call-queue-test.cpp index f7a998415..b391ef9a3 100644 --- a/tests/basics/call-queue-test.cpp +++ b/tests/basics/call-queue-test.cpp @@ -42,7 +42,7 @@ namespace lib { namespace test{ using lib::Sync; - using backend::ThreadJoinable; + using vault::ThreadJoinable; using util::isnil; using std::string; @@ -106,7 +106,7 @@ namespace test{ * - multithreaded stress test * * @see lib::CallQueue - * @see gui::NotificationService usage example + * @see stage::NotificationService usage example * @see [DemoGuiRoundtrip](http://issues.lumiera.org/ticket/1099 "Ticket #1099") */ class CallQueue_test : public Test diff --git a/tests/basics/diagnostic-context-test.cpp b/tests/basics/diagnostic-context-test.cpp index a621aedfd..2c84e2f51 100644 --- a/tests/basics/diagnostic-context-test.cpp +++ b/tests/basics/diagnostic-context-test.cpp @@ -55,7 +55,7 @@ namespace test{ } // (End) test setup.... - using backend::ThreadJoinable; + using vault::ThreadJoinable; using error::LERR_(LOGIC); using std::rand; @@ -83,7 +83,7 @@ namespace test{ * * @see lib::DiagnosticContext * @see lib::ThreadLocal - * @see backend::Thread + * @see vault::Thread */ class DiagnosticContext_test : public Test { diff --git a/tests/basics/time/time-control-test.cpp b/tests/basics/time/time-control-test.cpp index 9455d2cc6..bd70f5cc6 100644 --- a/tests/basics/time/time-control-test.cpp +++ b/tests/basics/time/time-control-test.cpp @@ -54,7 +54,7 @@ namespace test{ namespace error = lumiera::error; using lib::ScopedHolder; - using proc::asset::meta::TimeGrid; + using steam::asset::meta::TimeGrid; using lib::meta::Types; using lib::meta::InstantiateChainedCombinations; using error::LERR_(UNCONNECTED); diff --git a/tests/basics/time/time-formats-test.cpp b/tests/basics/time/time-formats-test.cpp index 8fa23ae2e..4802e6bae 100644 --- a/tests/basics/time/time-formats-test.cpp +++ b/tests/basics/time/time-formats-test.cpp @@ -47,7 +47,7 @@ namespace lib { namespace time{ namespace test{ - using proc::asset::meta::TimeGrid; + using steam::asset::meta::TimeGrid; using util::toString; using format::Frames; using format::Smpte; diff --git a/tests/basics/time/time-mutation-test.cpp b/tests/basics/time/time-mutation-test.cpp index bf20a68c6..f7c54dd44 100644 --- a/tests/basics/time/time-mutation-test.cpp +++ b/tests/basics/time/time-mutation-test.cpp @@ -45,7 +45,7 @@ namespace lib { namespace time{ namespace test{ - using proc::asset::meta::TimeGrid; + using steam::asset::meta::TimeGrid; namespace { inline string diff --git a/tests/basics/time/time-parsing-test.cpp b/tests/basics/time/time-parsing-test.cpp index eaa574f63..1f2cbf284 100644 --- a/tests/basics/time/time-parsing-test.cpp +++ b/tests/basics/time/time-parsing-test.cpp @@ -41,7 +41,7 @@ namespace lib { namespace time{ namespace test{ - using proc::asset::meta::TimeGrid; + using steam::asset::meta::TimeGrid; using format::LERR_(INVALID_TIMECODE); diff --git a/tests/basics/time/time-quantisation-test.cpp b/tests/basics/time/time-quantisation-test.cpp index 49ee145de..96b9383e4 100644 --- a/tests/basics/time/time-quantisation-test.cpp +++ b/tests/basics/time/time-quantisation-test.cpp @@ -45,7 +45,7 @@ namespace lib { namespace time{ namespace test{ - using proc::asset::meta::TimeGrid; + using steam::asset::meta::TimeGrid; /****************************************************//** diff --git a/tests/basics/typed-counter-test.cpp b/tests/basics/typed-counter-test.cpp index cc233b8ad..aea1ea745 100644 --- a/tests/basics/typed-counter-test.cpp +++ b/tests/basics/typed-counter-test.cpp @@ -59,7 +59,7 @@ namespace lib { namespace test{ - using backend::ThreadJoinable; + using vault::ThreadJoinable; using util::for_each; using util::isnil; using std::placeholders::_1; diff --git a/tests/core/application/subsystem-runner-test.cpp b/tests/core/application/subsystem-runner-test.cpp index 0441b2596..7c0315997 100644 --- a/tests/core/application/subsystem-runner-test.cpp +++ b/tests/core/application/subsystem-runner-test.cpp @@ -47,7 +47,7 @@ using util::cStr; using test::Test; using lib::Literal; using lib::query::extractID; -using backend::Thread; +using vault::Thread; namespace lumiera { diff --git a/tests/core/steam/asset/create-asset-test.cpp b/tests/core/steam/asset/create-asset-test.cpp index 8584353f0..8150dfc1b 100644 --- a/tests/core/steam/asset/create-asset-test.cpp +++ b/tests/core/steam/asset/create-asset-test.cpp @@ -51,8 +51,8 @@ namespace steam { namespace asset{ namespace test { - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/asset/dependent-assets-test.cpp b/tests/core/steam/asset/dependent-assets-test.cpp index 24822a28f..5e2f1cac8 100644 --- a/tests/core/steam/asset/dependent-assets-test.cpp +++ b/tests/core/steam/asset/dependent-assets-test.cpp @@ -42,8 +42,8 @@ namespace steam { namespace asset{ namespace test { - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/asset/entry-id-test.cpp b/tests/core/steam/asset/entry-id-test.cpp index 19ab1ae57..738faa43b 100644 --- a/tests/core/steam/asset/entry-id-test.cpp +++ b/tests/core/steam/asset/entry-id-test.cpp @@ -63,8 +63,8 @@ namespace test{ } using DummyID = EntryID; - using ForkID = EntryID; - using ClipID = EntryID; + using ForkID = EntryID; + using ClipID = EntryID; @@ -135,10 +135,10 @@ namespace test{ void checkBasicProperties () { - using proc::asset::Asset; - using proc::asset::STRUCT; - using proc::asset::Category; - using proc::asset::idi::getAssetIdent; + using steam::asset::Asset; + using steam::asset::STRUCT; + using steam::asset::Category; + using steam::asset::idi::getAssetIdent; ForkID tID(" test ⚡ ☠ ☭ ⚡ track "); @@ -233,8 +233,8 @@ namespace test{ CHECK (bIDf.getSym() == bIDc.getSym()); CHECK ("suspicious" == bIDc.getSym()); - using proc::mobject::session::Fork; - using proc::mobject::session::Clip; + using steam::mobject::session::Fork; + using steam::mobject::session::Clip; ForkID tIDnew = bIDf.recast(); ClipID cIDnew = bIDc.recast(); CHECK (tIDnew == fID); diff --git a/tests/core/steam/asset/identity-of-assets-test.cpp b/tests/core/steam/asset/identity-of-assets-test.cpp index 1df41d917..0aa2877eb 100644 --- a/tests/core/steam/asset/identity-of-assets-test.cpp +++ b/tests/core/steam/asset/identity-of-assets-test.cpp @@ -45,8 +45,8 @@ namespace steam { namespace asset{ namespace test { - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/asset/make-clip-test.cpp b/tests/core/steam/asset/make-clip-test.cpp index e0689b6a3..ec30a3e67 100644 --- a/tests/core/steam/asset/make-clip-test.cpp +++ b/tests/core/steam/asset/make-clip-test.cpp @@ -47,8 +47,8 @@ namespace steam { namespace asset{ namespace test { - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/asset/ordering-of-assets-test.cpp b/tests/core/steam/asset/ordering-of-assets-test.cpp index bf14aa557..ec7ad975e 100644 --- a/tests/core/steam/asset/ordering-of-assets-test.cpp +++ b/tests/core/steam/asset/ordering-of-assets-test.cpp @@ -44,8 +44,8 @@ namespace steam { namespace asset{ namespace test { - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/asset/typed-id-test.cpp b/tests/core/steam/asset/typed-id-test.cpp index e8e086d5e..7abc91981 100644 --- a/tests/core/steam/asset/typed-id-test.cpp +++ b/tests/core/steam/asset/typed-id-test.cpp @@ -76,7 +76,7 @@ namespace query { * Of course this is a test/dummy/demonstration. */ template<> - struct TypeHandlerXX + struct TypeHandlerXX { static Symbol getID() { return "typed-id-test-dummy"; } @@ -90,8 +90,8 @@ namespace lib { namespace idi { namespace test{ - using proc::mobject::session::test::DummyEntity; - using proc::mobject::session::test::PDum; + using steam::mobject::session::test::DummyEntity; + using steam::mobject::session::test::PDum; using DummyID = EntryID; diff --git a/tests/core/steam/control/command-instance-manager-test.cpp b/tests/core/steam/control/command-instance-manager-test.cpp index 52b08610a..66678cf4d 100644 --- a/tests/core/steam/control/command-instance-manager-test.cpp +++ b/tests/core/steam/control/command-instance-manager-test.cpp @@ -110,7 +110,7 @@ namespace test { * actual arguments and finally handed over to the ProcDispatcher * for invocation. * - * @see proc::control::CommandInstanceManager + * @see steam::control::CommandInstanceManager */ class CommandInstanceManager_test : public Test { diff --git a/tests/core/steam/control/command-setup-test.cpp b/tests/core/steam/control/command-setup-test.cpp index 11223c5ca..9066a78dc 100644 --- a/tests/core/steam/control/command-setup-test.cpp +++ b/tests/core/steam/control/command-setup-test.cpp @@ -101,7 +101,7 @@ namespace test { * * @see cmd.hpp * @see session-cmd.cpp actual usage example - * @see proc::control::CommandSetup + * @see steam::control::CommandSetup */ class CommandSetup_test : public Test { @@ -220,7 +220,7 @@ namespace test { * - static CommandSetup instances are created "somewhere" * - when the ON_GLOBAL_INIT [lifecycle event](\ref lifecycle.h) is * issued, all command definitions collected thus far are invoked - * and thus inserted into the proc::control::CommandRegistry + * and thus inserted into the steam::control::CommandRegistry * - from this point on, we may access a control::Command handle * corresponding to these definitions, and we may create derived * instances to bind parameters and invoke the operation. diff --git a/tests/core/steam/control/dispatcher-looper-test.cpp b/tests/core/steam/control/dispatcher-looper-test.cpp index 0da8858e4..cac29bb9c 100644 --- a/tests/core/steam/control/dispatcher-looper-test.cpp +++ b/tests/core/steam/control/dispatcher-looper-test.cpp @@ -95,7 +95,7 @@ namespace test { * - detection and handling of work states * - management of builder run triggers * - * @see proc::control::Looper + * @see steam::control::Looper * @see DispatcherLoop * @see CommandQueue_test */ diff --git a/tests/core/steam/control/session-command-function-test.cpp b/tests/core/steam/control/session-command-function-test.cpp index 61eb7f716..8346c979b 100644 --- a/tests/core/steam/control/session-command-function-test.cpp +++ b/tests/core/steam/control/session-command-function-test.cpp @@ -100,7 +100,7 @@ namespace test { using boost::lexical_cast; using lib::test::randTime; - using proc::control::SessionCommand; + using steam::control::SessionCommand; using lib::diff::GenNode; using lib::diff::Rec; using lib::time::Time; @@ -174,12 +174,12 @@ namespace test { * - operate lifecycle of the supporting components, * similar to activating the »session subsystem« * - generate command messages similar to what is received from the UI-Bus - * - us the handler mechanism from gui::ctrl::CoreService to talk to the facade + * - us the handler mechanism from stage::ctrl::CoreService to talk to the facade * - have a specially rigged command function to observe invocation * - wait for the session loop thread to dispatch this command * - verify that commands are really executed single-threaded * - * @see proc::SessionSubsystem + * @see steam::SessionSubsystem * @see ProcDispatcher * @see CommandQueue_test * @see AbstractTangible_test::invokeCommand() @@ -284,7 +284,7 @@ namespace test { /** @test invoke a command in the same way as CoreService does * when handling command messages from the UI-Bus * - build a command message, similar to what the - * [generic UI element](\ref gui::model::Tangible) does + * [generic UI element](\ref stage::model::Tangible) does * - use the contents of this message at the SessionCommand * facade, similar to what CoreService does */ @@ -323,7 +323,7 @@ namespace test { // we'll run several instances of the following thread.... class InvocationProducer - : backend::ThreadJoinable + : vault::ThreadJoinable { FamilyMember id_; vector cmdIDs_; diff --git a/tests/core/steam/engine/buffer-provider-protocol-test.cpp b/tests/core/steam/engine/buffer-provider-protocol-test.cpp index b93b885e3..d8a6edb2d 100644 --- a/tests/core/steam/engine/buffer-provider-protocol-test.cpp +++ b/tests/core/steam/engine/buffer-provider-protocol-test.cpp @@ -45,7 +45,7 @@ namespace test { using lib::test::Dummy; - using proc::engine::BuffHandle; + using steam::engine::BuffHandle; using error::LERR_(LOGIC); using error::LERR_(LIFECYCLE); diff --git a/tests/core/steam/engine/engine-interface-test.cpp b/tests/core/steam/engine/engine-interface-test.cpp index d358c6938..3cd5dc8b2 100644 --- a/tests/core/steam/engine/engine-interface-test.cpp +++ b/tests/core/steam/engine/engine-interface-test.cpp @@ -50,8 +50,8 @@ namespace test { using asset::Pipe; using asset::PPipe; using mobject::ModelPort; - using proc::play::OutputSlot; - using proc::play::DiagnosticOutputSlot; + using steam::play::OutputSlot; + using steam::play::DiagnosticOutputSlot; using lib::time::FrameRate; typedef asset::ID PID; diff --git a/tests/core/steam/mobject/builder/builder-tool-test.cpp b/tests/core/steam/mobject/builder/builder-tool-test.cpp index ddeea3b54..21c7002b6 100644 --- a/tests/core/steam/mobject/builder/builder-tool-test.cpp +++ b/tests/core/steam/mobject/builder/builder-tool-test.cpp @@ -52,8 +52,8 @@ namespace test { using session::AbstractMO; using namespace mobject::test; - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/mobject/mobject-interface-test.cpp b/tests/core/steam/mobject/mobject-interface-test.cpp index 0f211bf6e..242f521fe 100644 --- a/tests/core/steam/mobject/mobject-interface-test.cpp +++ b/tests/core/steam/mobject/mobject-interface-test.cpp @@ -63,8 +63,8 @@ namespace test { // using session::Clip; // using session::PMedia; - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; using namespace mobject::test; diff --git a/tests/core/steam/mobject/mobject-ref-test.cpp b/tests/core/steam/mobject/mobject-ref-test.cpp index d15c62a83..f37b36a9c 100644 --- a/tests/core/steam/mobject/mobject-ref-test.cpp +++ b/tests/core/steam/mobject/mobject-ref-test.cpp @@ -83,8 +83,8 @@ namespace test { using session::SessionServiceMockIndex; using session::PPIdx; - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; diff --git a/tests/core/steam/mobject/placement-hierarchy-test.cpp b/tests/core/steam/mobject/placement-hierarchy-test.cpp index ec61e0c90..5b11dc786 100644 --- a/tests/core/steam/mobject/placement-hierarchy-test.cpp +++ b/tests/core/steam/mobject/placement-hierarchy-test.cpp @@ -51,8 +51,8 @@ namespace test { using namespace mobject::test; using lumiera::error::LUMIERA_ERROR_ASSERTION; - using MediaAccessMock = lib::DependInject - ::Local; + using MediaAccessMock = lib::DependInject + ::Local; /***********************************************************************************//** diff --git a/tests/core/steam/mobject/session/defs-manager-impl-test.cpp b/tests/core/steam/mobject/session/defs-manager-impl-test.cpp index 9ad83afa4..b8c9081d2 100644 --- a/tests/core/steam/mobject/session/defs-manager-impl-test.cpp +++ b/tests/core/steam/mobject/session/defs-manager-impl-test.cpp @@ -60,7 +60,7 @@ namespace test { using lumiera::query::QueryHandler; using lib::query::normaliseID; - using proc::ConfigResolver; + using steam::ConfigResolver; namespace { // test fixture... diff --git a/tests/core/steam/mobject/session/testclip.cpp b/tests/core/steam/mobject/session/testclip.cpp index 03d50d5b9..ac838e23c 100644 --- a/tests/core/steam/mobject/session/testclip.cpp +++ b/tests/core/steam/mobject/session/testclip.cpp @@ -46,7 +46,7 @@ namespace test { using PM = shared_ptr; using MAF = backend_interface::MediaAccessFacade; - using MediaAccessMock = lib::DependInject::Local; + using MediaAccessMock = lib::DependInject::Local; diff --git a/tests/core/steam/play/diagnostic-output-slot.hpp b/tests/core/steam/play/diagnostic-output-slot.hpp index 78f63d0f9..1e24ce5e5 100644 --- a/tests/core/steam/play/diagnostic-output-slot.hpp +++ b/tests/core/steam/play/diagnostic-output-slot.hpp @@ -62,12 +62,12 @@ namespace play { using util::unConst; using util::contains; using lib::time::FrameRate; - using proc::asset::meta::PGrid; - using proc::asset::meta::TimeGrid; - using proc::engine::BufferDescriptor; - using proc::engine::test::TestFrame; - using proc::engine::TrackingHeapBlockProvider; - namespace diagn = proc::engine::diagn; + using steam::asset::meta::PGrid; + using steam::asset::meta::TimeGrid; + using steam::engine::BufferDescriptor; + using steam::engine::test::TestFrame; + using steam::engine::TrackingHeapBlockProvider; + namespace diagn = steam::engine::diagn; //using std::vector; using std::shared_ptr; diff --git a/tests/core/steam/play/dummy-play-connection-test.cpp b/tests/core/steam/play/dummy-play-connection-test.cpp index 08dd60438..1c57108e3 100644 --- a/tests/core/steam/play/dummy-play-connection-test.cpp +++ b/tests/core/steam/play/dummy-play-connection-test.cpp @@ -41,9 +41,9 @@ namespace test { namespace time = lib::time; - using proc::engine::BuffHandle; -//using proc::engine::test::testData; -//using proc::engine::test::TestFrame; + using steam::engine::BuffHandle; +//using steam::engine::test::testData; +//using steam::engine::test::TestFrame; using lumiera::Play; diff --git a/tests/core/steam/play/output-slot-protocol-test.cpp b/tests/core/steam/play/output-slot-protocol-test.cpp index 12a7edf77..165fb22b9 100644 --- a/tests/core/steam/play/output-slot-protocol-test.cpp +++ b/tests/core/steam/play/output-slot-protocol-test.cpp @@ -37,9 +37,9 @@ namespace steam { namespace play { namespace test { - using proc::engine::BuffHandle; - using proc::engine::test::testData; - using proc::engine::test::TestFrame; + using steam::engine::BuffHandle; + using steam::engine::test::testData; + using steam::engine::test::TestFrame; diff --git a/tests/core/steam/play/timing-constraints-test.cpp b/tests/core/steam/play/timing-constraints-test.cpp index 0afe2a2c4..378927cf4 100644 --- a/tests/core/steam/play/timing-constraints-test.cpp +++ b/tests/core/steam/play/timing-constraints-test.cpp @@ -43,9 +43,9 @@ namespace test { using lib::time::Duration; using lib::time::FrameRate; -//using proc::engine::BuffHandle; -//using proc::engine::test::testData; -//using proc::engine::test::TestFrame; +//using steam::engine::BuffHandle; +//using steam::engine::test::testData; +//using steam::engine::test::TestFrame; //using lumiera::Play; diff --git a/tests/core/vault/engine/scheduler-interface-test.cpp b/tests/core/vault/engine/scheduler-interface-test.cpp index 89cd5eef5..3b3f16f31 100644 --- a/tests/core/vault/engine/scheduler-interface-test.cpp +++ b/tests/core/vault/engine/scheduler-interface-test.cpp @@ -48,7 +48,7 @@ namespace test { namespace { // test fixture: scheduling a dummy job operation... - Time TEST_START_TIME (backend::RealClock::now()); + Time TEST_START_TIME (vault::RealClock::now()); const Duration TEST_FRAME_DURATION(FSecs(1,2)); inline Offset diff --git a/tests/core/vault/media-access-mock.cpp b/tests/core/vault/media-access-mock.cpp index c50a51304..b0f3d148e 100644 --- a/tests/core/vault/media-access-mock.cpp +++ b/tests/core/vault/media-access-mock.cpp @@ -93,7 +93,7 @@ namespace test { }; int Response::_i_(0); const ChanDesc NULLResponse; - using proc::mobject::session::test::LENGTH_TestClip; + using steam::mobject::session::test::LENGTH_TestClip; struct TestCases : map diff --git a/tests/library/iter-explorer-test.cpp b/tests/library/iter-explorer-test.cpp index 453a84076..51760a935 100644 --- a/tests/library/iter-explorer-test.cpp +++ b/tests/library/iter-explorer-test.cpp @@ -501,7 +501,7 @@ namespace test{ * where the "Explorer" function works together with a specific implementation * and exploits knowledge about specifically tailored additional properties of * the input sequence elements, in order to yield the desired overall effect. - * Actually this is what we use in the proc::engine::Dispatcher to generate + * Actually this is what we use in the steam::engine::Dispatcher to generate * a series of frame render jobs, including all prerequisite jobs */ void diff --git a/tests/library/meta/config-flags-test.cpp b/tests/library/meta/config-flags-test.cpp index 70efd90c7..6d9569e16 100644 --- a/tests/library/meta/config-flags-test.cpp +++ b/tests/library/meta/config-flags-test.cpp @@ -57,7 +57,7 @@ namespace lib { namespace meta { namespace test { - using proc::engine::config::Instantiation; + using steam::engine::config::Instantiation; namespace { // internal definitions @@ -292,7 +292,7 @@ cout << "__________________________\n" \ typedef Filter::Test> Possible_Configs; DISPLAY (Possible_Configs); - using proc::engine::config::ConfigSelector; + using steam::engine::config::ConfigSelector; typedef ConfigSelector< TestFactory // Factory template , uint(void) // Factory function type , long // common ctor argument diff --git a/tests/library/meta/iterable-classification-test.cpp b/tests/library/meta/iterable-classification-test.cpp index f210715c9..ccfa1185b 100644 --- a/tests/library/meta/iterable-classification-test.cpp +++ b/tests/library/meta/iterable-classification-test.cpp @@ -46,8 +46,8 @@ namespace lib { namespace meta { namespace test { - using proc::mobject::session::Effect; - using proc::mobject::session::ScopeQuery; + using steam::mobject::session::Effect; + using steam::mobject::session::ScopeQuery; typedef lib::time::TimeVar Time; using std::cout; diff --git a/tests/library/meta/tuple-record-init-test.cpp b/tests/library/meta/tuple-record-init-test.cpp index 48b075314..075f5b877 100644 --- a/tests/library/meta/tuple-record-init-test.cpp +++ b/tests/library/meta/tuple-record-init-test.cpp @@ -76,7 +76,7 @@ namespace test { * @see ElementExtractor * @see GenNodeAccessor * @see BusTerm_test::commandInvocation - * @see gui::test::Nexus::prepareDiagnosticCommandHandler + * @see stage::test::Nexus::prepareDiagnosticCommandHandler * @see ui-bus.hpp UI-Bus */ class TupleRecordInit_test : public Test diff --git a/tests/library/meta/type-display-test.cpp b/tests/library/meta/type-display-test.cpp index 01886295c..38e8e1e6b 100644 --- a/tests/library/meta/type-display-test.cpp +++ b/tests/library/meta/type-display-test.cpp @@ -56,8 +56,8 @@ namespace test{ struct Space { }; auto CHALLENGE_1 = "some::arbitrary::BullShit*"; - auto CHALLENGE_2 = "lib::Contrived::ClusterFuck)>"; - auto CHALLENGE_3 = "std::function>)>"; + auto CHALLENGE_2 = "lib::Contrived::ClusterFuck)>"; + auto CHALLENGE_3 = "std::function>)>"; }//(end)fixture @@ -75,7 +75,7 @@ namespace test{ * * strip some frequent namespace prefixes * ** `std::` * ** `lib::meta::` - * ** `proc::mobject::` + * ** `steam::mobject::` * * omit the standard allocator from STL containers * - the third example demonstrates an embedded function signature * * the primary type component is "`function`" diff --git a/tests/library/replaceable-item-test.cpp b/tests/library/replaceable-item-test.cpp index c9922b92d..a71424c92 100644 --- a/tests/library/replaceable-item-test.cpp +++ b/tests/library/replaceable-item-test.cpp @@ -92,7 +92,7 @@ namespace test{ * - compare by delegating to element comparison * * @see replaceable-item.hpp - * @see proc::control::MementoTie + * @see steam::control::MementoTie */ class ReplaceableItem_test : public Test { diff --git a/tests/stage/abstract-tangible-test.cpp b/tests/stage/abstract-tangible-test.cpp index 0a7b23e1a..87afc3b79 100644 --- a/tests/stage/abstract-tangible-test.cpp +++ b/tests/stage/abstract-tangible-test.cpp @@ -24,8 +24,8 @@ /** @file abstract-tangible-test.cpp ** Verify the common base shared by all interface elements of relevance. ** This test is not so much a test, than a test of the test support for testing - ** [primary elements](\ref gui::model::Tangible) of the Lumiera GTK UI. Any such element - ** is connected to the [UI-Bus](\ref gui::UiBus) and responds to some generic actions and + ** [primary elements](\ref stage::model::Tangible) of the Lumiera GTK UI. Any such element + ** is connected to the [UI-Bus](\ref stage::UiBus) and responds to some generic actions and ** interaction patterns. This is the foundation of any presentation state recording ** and restoration, and it serves to invoke any persistent action on the ** [Session] through a single channel and access point. @@ -39,7 +39,7 @@ ** @todo WIP ///////////////////////TICKET #956 : model diff representation ** @todo WIP ///////////////////////TICKET #961 : tests to pass... ** - ** @see gui::UiBus + ** @see stage::UiBus ** */ @@ -67,7 +67,7 @@ using lib::Symbol; using util::isnil; using util::toString; using lib::time::Time; -using gui::test::MockElm; +using stage::test::MockElm; using lib::test::EventLog; using lib::idi::EntryID; using lib::diff::Rec; @@ -75,8 +75,8 @@ using lib::diff::MakeRec; using lib::diff::GenNode; using lib::diff::DataCap; using lib::diff::MutationMessage; -using proc::control::Command; -using proc::control::CommandDef; +using steam::control::Command; +using steam::control::CommandDef; @@ -202,7 +202,7 @@ namespace test { * to the session, but any command- or other messages will be captured and can be * retrieved or verified from the test code. Since lifecycle and robustness in * "post mortem" situations tend to be tricky for UI code, we provide a dedicated - * ["zombification" feature](\ref gui::test::TestNexus::zombificate): a \ref MockElm can be + * ["zombification" feature](\ref stage::test::TestNexus::zombificate): a \ref MockElm can be * turned into an _almost dead_ state, while still hanging around. It will be detached from * the "living" Test-Nexus and re-wired to some special, hidden "Zombie Nexus", causing any * further messaging activity to be logged and ignored. @@ -288,7 +288,7 @@ namespace test { .beforeCall("doMsg").on("foo")); // Access the log on the Test-Nexus hub - EventLog nexusLog = gui::test::Nexus::getLog(); + EventLog nexusLog = stage::test::Nexus::getLog(); CHECK (nexusLog.verifyEvent("destroy","dummy") .beforeEvent("dummy successfully zombificated")); @@ -303,7 +303,7 @@ namespace test { << "\n───╼━━━━━━━━━╾────────────────"< trigger_expand; sigc::signal trigger_collapse; @@ -427,7 +427,7 @@ namespace test { // Second part: replay of a state mark via UI-Bus.... auto stateMark = GenNode{"expand", true}; - auto& uiBus = gui::test::Nexus::testUI(); + auto& uiBus = stage::test::Nexus::testUI(); CHECK (not mock.isExpanded()); CHECK (mock.ensureNot("mark")); @@ -478,7 +478,7 @@ namespace test { revealer () { MARK_TEST_FUN - EventLog nexusLog = gui::test::Nexus::startNewLog(); + EventLog nexusLog = stage::test::Nexus::startNewLog(); MockElm mock("target"); ID targetID = mock.getID(); @@ -516,7 +516,7 @@ namespace test { // second test: the same can be achieved via UI-Bus message... revealed = false; auto stateMark = GenNode{"reveal", 47}; // (payload argument irrelevant) - auto& uiBus = gui::test::Nexus::testUI(); + auto& uiBus = stage::test::Nexus::testUI(); CHECK (nexusLog.ensureNot("reveal")); uiBus.mark (targetID, stateMark); // send the state mark message to reveal the element @@ -562,11 +562,11 @@ namespace test { notify () { MARK_TEST_FUN - EventLog nexusLog = gui::test::Nexus::startNewLog(); + EventLog nexusLog = stage::test::Nexus::startNewLog(); MockElm mock("target"); ID targetID = mock.getID(); - auto& uiBus = gui::test::Nexus::testUI(); + auto& uiBus = stage::test::Nexus::testUI(); CHECK (mock.ensureNot("Flash")); CHECK (mock.ensureNot("Error")); @@ -660,7 +660,7 @@ namespace test { mutate () { MARK_TEST_FUN - EventLog nexusLog = gui::test::Nexus::startNewLog(); + EventLog nexusLog = stage::test::Nexus::startNewLog(); MockElm rootMock("root"); ID rootID = rootMock.getID(); @@ -697,7 +697,7 @@ namespace test { diffSrc; - auto& uiBus = gui::test::Nexus::testUI(); + auto& uiBus = stage::test::Nexus::testUI(); // send a Diff message via UI-Bus to the rootMock diff --git a/tests/stage/bus-term-test.cpp b/tests/stage/bus-term-test.cpp index 4765e227b..f92f80463 100644 --- a/tests/stage/bus-term-test.cpp +++ b/tests/stage/bus-term-test.cpp @@ -54,7 +54,7 @@ using boost::lexical_cast; using lib::Sync; using lib::ClassLock; -using backend::ThreadJoinable; +using vault::ThreadJoinable; using lib::iter_stl::dischargeToSnapshot; using lib::IterQueue; using lib::IterStack; @@ -70,10 +70,10 @@ namespace test { using lib::idi::EntryID; using lib::idi::BareEntryID; - using proc::control::Command; - using gui::ctrl::StateManager; - using gui::ctrl::BusTerm; - using gui::test::MockElm; + using steam::control::Command; + using stage::ctrl::StateManager; + using stage::ctrl::BusTerm; + using stage::test::MockElm; using lib::diff::MutationMessage; using lib::diff::TreeDiffLanguage; using lib::diff::DiffSource; @@ -88,7 +88,7 @@ namespace test { using lib::test::EventLog; using lib::CallQueue; - using proc::control::LUMIERA_ERROR_UNBOUND_ARGUMENTS; + using steam::control::LUMIERA_ERROR_UNBOUND_ARGUMENTS; using lumiera::error::LUMIERA_ERROR_WRONG_TYPE; using ID = lib::idi::BareEntryID const&; @@ -129,8 +129,8 @@ namespace test { * - multithreaded integration test of diff mutation * * @see AbstractTangible_test - * @see gui::model::Tangible - * @see gui::ctrl::BusTerm + * @see stage::model::Tangible + * @see stage::ctrl::BusTerm */ class BusTerm_test : public Test { @@ -167,7 +167,7 @@ namespace test { BareEntryID elmID = EntryID{"zeitgeist"}; // Access the log on the Test-Nexus hub - EventLog nexusLog = gui::test::Nexus::startNewLog(); + EventLog nexusLog = stage::test::Nexus::startNewLog(); CHECK (nexusLog.ensureNot("zeitgeist")); MockElm mock(elmID); @@ -191,7 +191,7 @@ namespace test { CHECK (nexusLog.verifyCall("note").on("TestNexus").arg(elmID, "GenNode-ID(\"expand\")-DataCap|«bool»|true")); // send a state mark down to the mock element - gui::test::Nexus::testUI().mark (elmID, GenNode(string{MARK_Flash}, 23)); + stage::test::Nexus::testUI().mark (elmID, GenNode(string{MARK_Flash}, 23)); CHECK (nexusLog.verifyCall("mark").on("TestNexus").arg(elmID, MARK_Flash) .beforeEvent("TestNexus", "mark to bID-zeitgeist")); CHECK (elmLog.verifyCall("doFlash").on("zeitgeist")); @@ -203,7 +203,7 @@ namespace test { CHECK (nexusLog.verifyCall("routeDetach").on("TestNexus").arg(elmID) .beforeEvent("TestNexus", "removed route to bID-zeitgeist")); - gui::test::Nexus::testUI().mark (elmID, GenNode({MARK_Flash}, 88)); + stage::test::Nexus::testUI().mark (elmID, GenNode({MARK_Flash}, 88)); CHECK (nexusLog.verify("removed route to bID-zeitgeist") .beforeCall("mark").on("TestNexus").arg(elmID, MARK_Flash) .beforeEvent("warn","discarding mark to unknown bID-zeitgeist")); @@ -216,7 +216,7 @@ namespace test { << "\n───╼━━━━━━━━━╾────────────────"<(); + stage::test::Nexus::startNewLog(); + Symbol cmd = stage::test::Nexus::prepareMockCmd(); MockElm mock("uiElm"); @@ -249,27 +249,27 @@ namespace test { mock.invoke (cmd, text, clip, luid); CHECK (Command::canExec(cmd)); - CHECK (gui::test::Nexus::wasBound(cmd, text, clip, luid)); - CHECK (not gui::test::Nexus::wasBound(cmd, "lololo")); - CHECK (gui::test::Nexus::wasInvoked(cmd)); - CHECK (gui::test::Nexus::wasInvoked(cmd, text, clip, luid)); - CHECK (not gui::test::Nexus::wasInvoked(cmd, " huh ", clip, luid)); - CHECK (not gui::test::Nexus::wasInvoked(cmd, text, clip)); + CHECK (stage::test::Nexus::wasBound(cmd, text, clip, luid)); + CHECK (not stage::test::Nexus::wasBound(cmd, "lololo")); + CHECK (stage::test::Nexus::wasInvoked(cmd)); + CHECK (stage::test::Nexus::wasInvoked(cmd, text, clip, luid)); + CHECK (not stage::test::Nexus::wasInvoked(cmd, " huh ", clip, luid)); + CHECK (not stage::test::Nexus::wasInvoked(cmd, text, clip)); // Mock commands are automatically unique - auto cmdX = gui::test::Nexus::prepareMockCmd<>(); - auto cmdY = gui::test::Nexus::prepareMockCmd<>(); + auto cmdX = stage::test::Nexus::prepareMockCmd<>(); + auto cmdY = stage::test::Nexus::prepareMockCmd<>(); CHECK (cmd != cmdX); CHECK (cmd != cmdY); - CHECK (not gui::test::Nexus::wasInvoked(cmdX)); - CHECK (not gui::test::Nexus::wasInvoked(cmdY)); + CHECK (not stage::test::Nexus::wasInvoked(cmdX)); + CHECK (not stage::test::Nexus::wasInvoked(cmdY)); cout << "____Nexus-Log_________________\n" - << util::join(gui::test::Nexus::getLog(), "\n") + << util::join(stage::test::Nexus::getLog(), "\n") << "\n───╼━━━━━━━━━╾────────────────"<::Local<>; using MockElementAccess = lib::DependInject::Local; diff --git a/tests/stage/model/element-access-test.cpp b/tests/stage/model/element-access-test.cpp index 5f6a2dc98..afb490ba9 100644 --- a/tests/stage/model/element-access-test.cpp +++ b/tests/stage/model/element-access-test.cpp @@ -57,10 +57,10 @@ namespace test { // using lumiera::error::LUMIERA_ERROR_WRONG_TYPE; // using lib::test::showSizeof; using interact::UICoord; - using gui::test::TestElementAccess; - using gui::test::DummyWidget; - using gui::test::DummyView; - using gui::test::DummyTab; + using stage::test::TestElementAccess; + using stage::test::DummyWidget; + using stage::test::DummyView; + using stage::test::DummyTab; using MockAccess = lib::DependInject::Local; using AccessAPI = lib::Depend; diff --git a/tests/stage/session-structure-mapping-test.cpp b/tests/stage/session-structure-mapping-test.cpp index c2f87faf5..dd40771c8 100644 --- a/tests/stage/session-structure-mapping-test.cpp +++ b/tests/stage/session-structure-mapping-test.cpp @@ -85,7 +85,7 @@ namespace test { * corrupted by concurrent session mutation operations. * * @see SessionElementQuery_test - * @see gui::model::SessionFacade + * @see stage::model::SessionFacade */ class SessionStructureMapping_test : public Test { @@ -93,7 +93,7 @@ namespace test { virtual void run (Arg) { - gui::model::Diagnostics lock(TEST_SESSION_1); + stage::model::Diagnostics lock(TEST_SESSION_1); retrieveSessionStructure(); } diff --git a/tests/stage/test/mock-elm.hpp b/tests/stage/test/mock-elm.hpp index 4f502428a..3e287323b 100644 --- a/tests/stage/test/mock-elm.hpp +++ b/tests/stage/test/mock-elm.hpp @@ -24,16 +24,16 @@ /** @file mock-elm.hpp ** A generic interface element instrumented for unit testing. ** All relevant building blocks within the Lumiera GTK UI are based on - ** gui::model::Tangible, meaning that any generic effect of interface interactions + ** stage::model::Tangible, meaning that any generic effect of interface interactions ** can be expressed in terms of this interface contract. As far as the UI participates ** in interactions with the lower layers, like e.g. command invocation, structure updates ** and state notifications, these processes can be modelled and verified with the help - ** of a specially prepared Tangible instance. This gui::test::MockElm provides the + ** of a specially prepared Tangible instance. This stage::test::MockElm provides the ** necessary instrumentation to observe what has been invoked and received. ** ** Since the purpose of a mock interface element is to test interactions and responses ** targeted at a generic interface element, the MockElm incorporates an implementation - ** independent from the real gui::model::Widget or gui::model::Controller. This + ** independent from the real stage::model::Widget or stage::model::Controller. This ** mock implementation is basically NOP, while logging any invocation. Matters get ** a bit fuzzy, when it comes to the distinction between _widget_ and _controller_. ** Yet we should note that the purpose of this setup is to cover the connectivity @@ -48,7 +48,7 @@ ** built with a distinct core, the UI should not contain anything not tangible enough ** as just to be verified by watching it in action. The push of a button should just ** invoke an action, and the action itself should be self contained enough to be - ** tested in isolation. The UI-Bus and the [generic widget base](\ref gui::model::Tangible) + ** tested in isolation. The UI-Bus and the [generic widget base](\ref stage::model::Tangible) ** was built to serve as a foundation to achieve that goal. ** ** @see abstract-tangible-test.cpp @@ -108,9 +108,9 @@ namespace test{ * @see abstract-tangible-test.cpp */ class MockElm - : public gui::model::Tangible + : public stage::model::Tangible { - using _Par = gui::model::Tangible; + using _Par = stage::model::Tangible; EventLog log_{this->identify()}; @@ -303,7 +303,7 @@ namespace test{ explicit MockElm(ID identity, ctrl::BusTerm& nexus =Nexus::testUI()) - : gui::model::Tangible(identity, nexus) + : stage::model::Tangible(identity, nexus) { log_.call (this->identify(), "ctor", identity, string(nexus)); log_.create (getID().getSym()); diff --git a/tests/stage/test/placeholder-command.hpp b/tests/stage/test/placeholder-command.hpp index 9fe2788dc..55741f1b9 100644 --- a/tests/stage/test/placeholder-command.hpp +++ b/tests/stage/test/placeholder-command.hpp @@ -114,11 +114,11 @@ namespace test{ public: - static proc::control::Command + static steam::control::Command fabricateNewInstance (lib::test::EventLog const& invocationLog) { log_ = invocationLog; - return proc::control::CommandDef{Symbol{uniqueTypeInstance()}} + return steam::control::CommandDef{Symbol{uniqueTypeInstance()}} .operation(PlaceholderCommand::operate) .captureUndo(PlaceholderCommand::capture) .undoOperation(PlaceholderCommand::undo); diff --git a/tests/stage/test/test-nexus.cpp b/tests/stage/test/test-nexus.cpp index cc7836996..2eb38c2fd 100644 --- a/tests/stage/test/test-nexus.cpp +++ b/tests/stage/test/test-nexus.cpp @@ -25,7 +25,7 @@ ** Implementation of a fake UI backbone for testing. ** This compilation unit provides the actual setup for running a faked ** user interface from unit tests. Test code is assumed to access those - ** features through the [front-end](\ref gui::test::TestNexus), while the + ** features through the [front-end](\ref stage::test::TestNexus), while the ** actual implementation instances are placed [as singletons](\ref depend.hpp) ** ** This test setup will mostly treat messages similar to the [real UI-Bus hub](\ref nexus.hpp), @@ -73,12 +73,12 @@ using lib::diff::DataCap; using lib::diff::MutationMessage; using lib::idi::instanceTypeID; using lib::test::EventLog; -using gui::ctrl::BusTerm; -using gui::ctrl::StateManager; -using gui::ctrl::StateRecorder; -using proc::control::Command; -using proc::control::CommandImpl; -using proc::control::HandlingPattern; +using stage::ctrl::BusTerm; +using stage::ctrl::StateManager; +using stage::ctrl::StateRecorder; +using steam::control::Command; +using steam::control::CommandImpl; +using steam::control::HandlingPattern; using util::_Fmt; namespace stage { @@ -87,14 +87,14 @@ namespace test{ namespace { // internal details - using BusHub = gui::ctrl::Nexus; + using BusHub = stage::ctrl::Nexus; /** * @internal fake interface backbone and unit test rig * for simulated command and presentation state handling. * This implementation embodies the routing functionality - * as found in the [real nexus](\ref gui::ctrl::Nexus), and additionally - * also implements the handler functions of the [gui::ctrl::CoreService]. + * as found in the [real nexus](\ref stage::ctrl::Nexus), and additionally + * also implements the handler functions of the [stage::ctrl::CoreService]. * The latter allows us to intercept command invocations and presentation * state messages */ diff --git a/tests/vault/sync-classlock-test.cpp b/tests/vault/sync-classlock-test.cpp index 0da4ea44d..4a3c14650 100644 --- a/tests/vault/sync-classlock-test.cpp +++ b/tests/vault/sync-classlock-test.cpp @@ -31,7 +31,7 @@ #include "vault/thread-wrapper.hpp" using test::Test; -using backend::ThreadJoinable; +using vault::ThreadJoinable; namespace lib { namespace test { diff --git a/tests/vault/sync-locking-test.cpp b/tests/vault/sync-locking-test.cpp index 10e2157db..d9d21fff5 100644 --- a/tests/vault/sync-locking-test.cpp +++ b/tests/vault/sync-locking-test.cpp @@ -126,7 +126,7 @@ namespace test{ */ class HavocThread { - backend::ThreadJoinable thread_; + vault::ThreadJoinable thread_; void doIt () diff --git a/tests/vault/sync-waiting-test.cpp b/tests/vault/sync-waiting-test.cpp index 4e9d7a40b..cd0cfc8bf 100644 --- a/tests/vault/sync-waiting-test.cpp +++ b/tests/vault/sync-waiting-test.cpp @@ -156,7 +156,7 @@ namespace test{ void waitPingPong (Token& tok) { - typedef backend::ThreadJoinable Thread; + typedef vault::ThreadJoinable Thread; Thread ping ("SyncWaiting ping", bind (&Token::getIt, &tok)); Thread pong ("SyncWaiting pong", bind (&Token::getIt, &tok)); diff --git a/tests/vault/thread-local-test.cpp b/tests/vault/thread-local-test.cpp index dc394f154..16c960cc3 100644 --- a/tests/vault/thread-local-test.cpp +++ b/tests/vault/thread-local-test.cpp @@ -33,7 +33,7 @@ #include using test::Test; -using backend::ThreadJoinable; +using vault::ThreadJoinable; using std::rand; @@ -91,7 +91,7 @@ namespace test{ * Create some threads, each referring to another piece of data * through the "same" wrapper instance. * - * @see backend::Thread + * @see vault::Thread * @see lib::ThreadLocal */ class ThreadLocal_test : public Test diff --git a/tests/vault/thread-wrapper-join-test.cpp b/tests/vault/thread-wrapper-join-test.cpp index dda6980ef..efa6565ff 100644 --- a/tests/vault/thread-wrapper-join-test.cpp +++ b/tests/vault/thread-wrapper-join-test.cpp @@ -54,7 +54,7 @@ namespace test { * @test use the Lumiera backend to create some new threads, additionally * synchronising with these child threads and waiting for termination. * - * @see backend::Thread + * @see vault::Thread * @see threads.h */ class ThreadWrapperJoin_test : public Test diff --git a/tests/vault/thread-wrapper-self-recognition-test.cpp b/tests/vault/thread-wrapper-self-recognition-test.cpp index a02e3ea79..d7931c585 100644 --- a/tests/vault/thread-wrapper-self-recognition-test.cpp +++ b/tests/vault/thread-wrapper-self-recognition-test.cpp @@ -63,7 +63,7 @@ namespace test { * executing within the thread itself. * * @see Thread::invokedWithinThread() - * @see proc::control::DispatcherLoop::stateIsSynched() + * @see steam::control::DispatcherLoop::stateIsSynched() */ class ThreadWrapperSelfRecognitionTest_test : public Test { diff --git a/tests/vault/thread-wrapper-test.cpp b/tests/vault/thread-wrapper-test.cpp index 3756eb09d..38f55e7b3 100644 --- a/tests/vault/thread-wrapper-test.cpp +++ b/tests/vault/thread-wrapper-test.cpp @@ -121,7 +121,7 @@ namespace vault { * lumiera::Thread wrapper for binding to an arbitrary operation * and passing the appropriate context. * - * @see backend::Thread + * @see vault::Thread * @see threads.h */ class ThreadWrapper_test : public Test