From 8e16149a25adb5883b75dfe9cd0ba251e9de41d8 Mon Sep 17 00:00:00 2001 From: Ichthyostega Date: Sun, 31 May 2015 02:03:24 +0200 Subject: [PATCH] Ticket #155: rename Track -> Fork (II) actual renaming of types and variables in the entire code base --- src/common/config-rules.hpp | 8 +- src/include/play-facade.h | 4 +- src/proc/asset.hpp | 2 +- src/proc/asset/entry-id.hpp | 2 +- src/proc/asset/sequence.cpp | 4 +- src/proc/asset/sequence.hpp | 21 +-- src/proc/asset/struct-factory-impl.hpp | 39 ++--- src/proc/asset/struct-scheme.hpp | 18 +-- src/proc/asset/struct.hpp | 13 +- src/proc/config-resolver.cpp | 6 +- src/proc/config-resolver.hpp | 2 +- src/proc/mobject/explicitplacement.hpp | 2 +- src/proc/mobject/placement-ref.hpp | 2 +- src/proc/mobject/placement.hpp | 2 +- src/proc/mobject/session/binding.cpp | 2 +- src/proc/mobject/session/fixedlocation.hpp | 8 +- src/proc/mobject/session/fork.cpp | 17 ++- src/proc/mobject/session/fork.hpp | 57 +++---- src/proc/mobject/session/locatingpin.cpp | 2 +- src/proc/mobject/session/locatingpin.hpp | 8 +- src/proc/mobject/session/mobjectfactory.cpp | 14 +- src/proc/mobject/session/mobjectfactory.hpp | 4 +- src/proc/mobject/session/placement-index.hpp | 3 +- src/proc/mobject/session/query-focus.hpp | 2 +- src/proc/mobject/session/scope-locator.hpp | 2 +- src/proc/mobject/session/scope.hpp | 4 +- .../session/session-interface-modules.hpp | 6 +- src/proc/mobject/session/session-query.hpp | 26 +--- src/proc/play/play-service.cpp | 4 +- tests/41asset.tests | 8 +- tests/core/proc/asset/entry-id-test.cpp | 58 +++---- .../proc/mobject/placement-basic-test.cpp | 2 +- .../session/session-modify-parts-test.cpp | 144 +++++++++--------- .../session/session-structure-test.cpp | 20 +-- .../timeline-sequence-handling-test.cpp | 20 +-- 35 files changed, 265 insertions(+), 271 deletions(-) diff --git a/src/common/config-rules.hpp b/src/common/config-rules.hpp index 1409e64b8..c583575ba 100644 --- a/src/common/config-rules.hpp +++ b/src/common/config-rules.hpp @@ -86,13 +86,13 @@ namespace lumiera { // resolve(O, Cap) :- make(O), capabilities(Cap). // capabilities(Q) :- call(Q). // - // stream(T, mpeg) :- type(T, track), type(P, pipe), resolve(P, stream(P,mpeg)), placed_to(P, T). + // stream(T, mpeg) :- type(T, fork), type(P, pipe), resolve(P, stream(P,mpeg)), placed_to(P, T). // // The type guard is inserted automatically, while the predicate implementations for // find/1, make/1, stream/2, and placed_to/2 are to be provided by the target types. // - // As a example, the goal ":-retrieve(T, stream(T,mpeg))." would search a Track object, try to - // retrieve a pipe object with stream-type=mpeg and associate the track with this Pipe. The + // As a example, the goal ":-retrieve(T, stream(T,mpeg))." would search a Fork object (a "track"), try to + // retrieve a pipe object with stream-type=mpeg and associate the Fork with this Pipe. The // predicate "stream(P,mpeg)" needs to be implemented (natively) for the pipe object. class Resolver @@ -173,7 +173,7 @@ namespace lumiera { // TODO: the Idea is to provide specialisations for the concrete types // we want to participate in the ConfigRules system.... // Thus we get the possibility to create a specific return type, - // e.g. return a P but a Placement, using the appropriate factory. + // e.g. return a P but a Placement, using the appropriate factory. // Of course then the definitions need to be split up in separate headers. diff --git a/src/include/play-facade.h b/src/include/play-facade.h index afd239abb..d3acd467d 100644 --- a/src/include/play-facade.h +++ b/src/include/play-facade.h @@ -125,7 +125,7 @@ namespace lumiera { typedef lib::IterSource::iterator Pipes; typedef proc::play::POutputManager Output; typedef proc::mobject::session::PClipMO Clip; - typedef proc::mobject::PTrack Track; + typedef proc::mobject::PFork Fork; typedef proc::asset::PTimeline Timeline; typedef proc::asset::PViewer Viewer; @@ -135,7 +135,7 @@ namespace lumiera { Controller perform(Pipes, Output); Controller perform(Timeline); Controller perform(Viewer); - Controller perform(Track); + Controller perform(Fork); Controller perform(Clip); protected: diff --git a/src/proc/asset.hpp b/src/proc/asset.hpp index 06298785d..0a86ae5f7 100644 --- a/src/proc/asset.hpp +++ b/src/proc/asset.hpp @@ -136,7 +136,7 @@ namespace asset { * - asset::Meta representing metadata, parametrisation, customisation. * * And of course there are various concrete Asset subclasses, like asset::Clip, - * asset::Effect, asset::Codec, asset::Track, asset::Dataset. + * asset::Effect, asset::Codec, asset::Dataset. * @note Assets objects have a strict unique identity and because of this are non-copyable. * You can not create an Asset derived object without registering it with the AssetManager * automatically. It is possible to copy the PAsset (smart pointer) though. diff --git a/src/proc/asset/entry-id.hpp b/src/proc/asset/entry-id.hpp index 2f9fb8367..2e3011f7c 100644 --- a/src/proc/asset/entry-id.hpp +++ b/src/proc/asset/entry-id.hpp @@ -183,7 +183,7 @@ namespace asset { * @todo As a temporary workaround, we hash the symbolic ID twice, but we should look * into using a better hash function ////////////TICKET #865 * - * @see mobject::session::Track + * @see mobject::session::Fork */ template struct EntryID diff --git a/src/proc/asset/sequence.cpp b/src/proc/asset/sequence.cpp index acf3e2462..88735f3a6 100644 --- a/src/proc/asset/sequence.cpp +++ b/src/proc/asset/sequence.cpp @@ -1,5 +1,5 @@ /* - Sequence - Compound of MObjects placed on a track tree. Building block of the Session + Sequence - Compound of MObjects placed within a tree of tracks. Building block of the Session Copyright (C) Lumiera.org 2009, Hermann Vosseler @@ -57,7 +57,7 @@ namespace asset { Sequence::unlink () { AutoRegistered::detach(); - TODO ("purge attached track"); //////////////////////////////////////////////TICKET #692 + TODO ("purge attached fork"); //////////////////////////////////////////////TICKET #692 Struct::unlink(); } diff --git a/src/proc/asset/sequence.hpp b/src/proc/asset/sequence.hpp index d681270e5..2efe61720 100644 --- a/src/proc/asset/sequence.hpp +++ b/src/proc/asset/sequence.hpp @@ -1,5 +1,5 @@ /* - SEQUENCE.hpp - Compound of MObjects placed on a track tree. Building block of the Session + SEQUENCE.hpp - Compound of MObjects placed within a tree of tracks. Building block of the Session Copyright (C) Lumiera.org 2009, Hermann Vosseler @@ -26,18 +26,21 @@ ** A Sequence is both a structural element of the session and part of the ** public session API exposed to clients for discovering the session contents ** and structure. Sequences are implemented as structural assets, delegating - ** the actual implementation to the track-MObjects within the model. + ** the actual implementation to the fork-MObjects within the model, which + ** naturally form the necessary recursive and nested structure. ** ** Contrary to usual habits in video/sound editing software, in Lumiera the - ** tracks form a tree and serve as backbone of the individual \em sequence, + ** "tracks" form a tree and serve as backbone of the individual \em sequence, ** as opposed to the timeline, which manages output and frame quantisation, - ** but not the track structure. + ** but do not hold any contents themselves. Thus, the sequence is really + ** a tree of nested scopes (session::mobject::Fork), together with all the + ** media elements placed within these scopes. ** ** Like every structural asset, the creation of sequences happens automatically ** on referral; Sequences can be queried from the StructFactory, providing additional ** requested capabilities. Commonly clients will retrieve a given sequence by query ** on the name-ID of the sequence: \c Struct::retrieve(Query ("id(theName).")) - ** Additionally, a specific root track may be requested: \c "id(theName),rootTrack(trackID)." + ** Additionally, a specific fork root may be requested: \c "id(theName),rootFork(trackID)." ** ** @see Session ** @see StructFactory @@ -66,8 +69,8 @@ namespace proc { namespace mobject { namespace session { - class Track; - typedef MORef RTrack; + class Fork; + typedef MORef RFork; }} @@ -86,9 +89,9 @@ namespace asset { : public Struct , public lib::AutoRegistered { - typedef mobject::session::RTrack RTrack; + typedef mobject::session::RFork RFork; - Sequence (Ident const&); //////////////////////////////////////////////TICKET #692 pass in track here + Sequence (Ident const&); //////////////////////////////////////////////TICKET #692 pass in fork here public: /** create and register a new Sequence instance */ diff --git a/src/proc/asset/struct-factory-impl.hpp b/src/proc/asset/struct-factory-impl.hpp index d1a4acb9e..5eccf8fe1 100644 --- a/src/proc/asset/struct-factory-impl.hpp +++ b/src/proc/asset/struct-factory-impl.hpp @@ -76,9 +76,10 @@ namespace asset { using proc::mobject::Session; using proc::mobject::MObject; using proc::mobject::session::Scope; - using proc::mobject::session::match_specificTrack; + using proc::mobject::session::match_specificFork; using proc::mobject::session::RBinding; - using proc::mobject::session::RTrack; + using proc::mobject::session::RFork; + using proc::mobject::session::Fork; using idi::StructTraits; @@ -134,22 +135,22 @@ namespace asset { } - /** either fetch or build a suitable root track for a new sequence */ - RTrack - getTrack_forSequence (string const& desiredID) + /** either fetch or build a suitable fork root for a new sequence */ + RFork + getFork_forSequence (string const& desiredID) { - RTrack track; + RFork fork; if (!isnil (desiredID)) - track = Session::current->elements.pick (match_specificTrack (desiredID)); + fork = Session::current->elements.pick (match_specificFork (desiredID)); - if (track && !Scope::containing (track.getRef()).isRoot()) + if (fork && !Scope::containing (fork.getRef()).isRoot()) { - UNIMPLEMENTED ("how to deal with 'stealing' a sub-track tree to a new sequence??"); + UNIMPLEMENTED ("how to deal with 'stealing' a fork sub-tree to a new sequence??"); } - if (!track) - track = Session::current->getRoot().attach (MObject::create (TrackID (desiredID))); + if (!fork) + fork = Session::current->getRoot().attach (MObject::create (ForkID (desiredID))); - return track; + return fork; } @@ -230,14 +231,14 @@ namespace asset { { // when we reach this point it is clear a suitable sequence doesn't yet exist in the model TODO ("actually extract properties/capabilities from the query..."); - string trackID = caps.extractID ("track"); - Query desiredTrack (isnil (trackID)? "" : "id("+trackID+")"); -// PTrack track = Session::current->query (desiredTrack); ///////////////////////////////////TICKET #639 + string forkID = caps.extractID ("fork"); + Query desiredFork (isnil (forkID)? "" : "id("+forkID+")"); +// PFork fork = Session::current->query (desiredFork); ///////////////////////////////////TICKET #639 // TODO: handle the following cases - // - track doesn't exist --> create and root attach it - // - track exists and is root attached, but belongs already to a sequence --> throw - // - track exists, but isn't root attached ---> what do do here? steal it?? - PSequence newSequence = Sequence::create (createIdent (caps)); ///////////TODO fed track in here + // - fork doesn't exist --> create and attach it as root + // - fork exists and is root attached, but belongs already to a sequence --> throw + // - fork exists, but isn't root attached ---> what do do here? steal it?? + PSequence newSequence = Sequence::create (createIdent (caps)); ///////////TODO fed fork in here ENSURE (newSequence); ///////////////////////TICKET #565 maybe store the capabilities query within the Struct asset somehow? return newSequence.get(); } diff --git a/src/proc/asset/struct-scheme.hpp b/src/proc/asset/struct-scheme.hpp index b0a8fe20f..35bb9a095 100644 --- a/src/proc/asset/struct-scheme.hpp +++ b/src/proc/asset/struct-scheme.hpp @@ -53,14 +53,13 @@ namespace proc { namespace mobject { namespace session { - class Track; + class Fork; class Clip; }} namespace asset{ - class Track; class Pipe; class ProcPatt; class Timeline; @@ -88,18 +87,11 @@ namespace asset{ }; - ///////////////////////////////////////////////////////////////////////////////////////////TICKET #581 intending to abandon asset::Track in favour of a plain EntryID - template<> struct StructTraits + template<> struct StructTraits { - static Symbol namePrefix() { return "track"; } - static Symbol catFolder() { return "tracks";} - static Symbol idSymbol() { return "track"; } - }; - template<> struct StructTraits - { - static Symbol namePrefix() { return "track"; } - static Symbol catFolder() { return "tracks";} - static Symbol idSymbol() { return "track"; } + static Symbol namePrefix() { return "fork"; } + static Symbol catFolder() { return "forks";} + static Symbol idSymbol() { return "fork"; } }; template<> struct StructTraits { diff --git a/src/proc/asset/struct.hpp b/src/proc/asset/struct.hpp index b5e21fa53..e8b6cea02 100644 --- a/src/proc/asset/struct.hpp +++ b/src/proc/asset/struct.hpp @@ -22,8 +22,8 @@ /** @file struct.hpp - ** Structural parts of the Session (e.g. Tracks) can be reflected - ** into the "bookkeeping view" as a specific Kind of Asset. + ** Structural parts of the Session (e.g. "tracks", i.e. Fork objects) can be + ** reflected into the "bookkeeping view" as a specific Kind of Asset. ** For the different \em kinds of Assets, we use sub-interfaces inheriting ** from the general Asset interface, each of which expose a distinguishing feature. ** In the case of structural assets, the key point is the ability to retrieve an @@ -31,9 +31,9 @@ ** on demand, just by referral. Thus, the collection of these assets provides a map ** for exploring the current session's structure and allow for tweaking of the ** default behaviour. - ** - Track acts as unique track ID (note: to be removed and replaced by a plain \c entryID ) ** - Timeline and Sequence are facades, part of the session API ** - Pipe is an attachment point for wiring connections and defines a StreamType + ** - "tracks" are implemented as Fork represented as \c entryID within the asset view. ** - ProcPatt is used as a blueprint in the build process, a standard connection pattern ** ** \par access and creation @@ -44,9 +44,10 @@ ** aren't deleted. Doing so would require a dedicated function which not only drops ** an asset instance from AssetManager, but also ensures removal of all properties ** within the model which could cause automatic re-creation of this asset. E.g. - ** purging a track asset (=unique trackID) requires removing or disconnecting - ** all placements referring to this track, which could be sub tracks, clips, - ** effects, automation or labels. + ** purging a track asset (=unique trackID) would necessitate to remove or + ** disconnect all placements located within the scope of the referred Fork; + ** this could be sub forks, clips, effects, automation or labels. + ** Obviously, this is way beyond the realm of asset management. ** ** @ingroup asset ** @see asset.hpp for explanation regarding asset IDs diff --git a/src/proc/config-resolver.cpp b/src/proc/config-resolver.cpp index 10e26d8cd..90a85e597 100644 --- a/src/proc/config-resolver.cpp +++ b/src/proc/config-resolver.cpp @@ -70,12 +70,12 @@ namespace query { using proc::asset::Sequence; using proc::asset::PSequence; - using proc::mobject::session::Track; - using proc::mobject::session::PTrack; + using proc::mobject::session::Fork; + using proc::mobject::session::PFork; template PPipe DefsManager::operator() (Query const&); template PProcPatt DefsManager::operator() (Query const&); - template PTrack DefsManager::operator() (Query const&); + template PFork DefsManager::operator() (Query const&); template PTimeline DefsManager::operator() (Query const&); template PSequence DefsManager::operator() (Query const&); diff --git a/src/proc/config-resolver.hpp b/src/proc/config-resolver.hpp index e9e19af67..fbaa05e49 100644 --- a/src/proc/config-resolver.hpp +++ b/src/proc/config-resolver.hpp @@ -70,7 +70,7 @@ namespace proc { * the list of all concrete types participating in the * rule based config query system */ - typedef lib::meta::Types < proc::mobject::session::Track + typedef lib::meta::Types < proc::mobject::session::Fork , proc::asset::Pipe , const proc::asset::ProcPatt , proc::asset::Timeline diff --git a/src/proc/mobject/explicitplacement.hpp b/src/proc/mobject/explicitplacement.hpp index 3d1e5c613..558be04f6 100644 --- a/src/proc/mobject/explicitplacement.hpp +++ b/src/proc/mobject/explicitplacement.hpp @@ -1,5 +1,5 @@ /* - EXPLICITPLACEMENT.hpp - special Placement yielding an absolute location (Time,Track) for a MObject + EXPLICITPLACEMENT.hpp - special Placement yielding an absolute location (Time,Output) for a MObject Copyright (C) Lumiera.org 2008, Hermann Vosseler diff --git a/src/proc/mobject/placement-ref.hpp b/src/proc/mobject/placement-ref.hpp index bd859e52b..d0b3fd94c 100644 --- a/src/proc/mobject/placement-ref.hpp +++ b/src/proc/mobject/placement-ref.hpp @@ -47,7 +47,7 @@ ** @note there is a twist concerning the nominal Placement hierarchy ** as generated by the return type of PlacementRef::operator*(). ** While the original Placement (as added to the session) might been - ** defined to mimic a more elaborate hierarchy (e.g. Placement + ** defined to mimic a more elaborate hierarchy (e.g. Placement ** inherits from Placement), the Placement returned here in ** these cases will just be a subclass or Placement ** (which in the mentioned example would mean it couldn't be diff --git a/src/proc/mobject/placement.hpp b/src/proc/mobject/placement.hpp index 4c9ad8c9c..25812e85c 100644 --- a/src/proc/mobject/placement.hpp +++ b/src/proc/mobject/placement.hpp @@ -39,7 +39,7 @@ ** is controlled and parametrised by a collection (chain) of LocatingPin objects. By adding ** to this chain, the position of the MObject is increasingly constrained. The simplest ** case of such constraining is to add a FixedLocation, thus placing the MObject at one - ** absolute position (time, track). + ** absolute position (time, output). ** ** Together, this yields semantics somewhere in between value semantics and reference semantics. ** As any smart-ptr, placements are copyable, but each such copy takes on a distinct identity. diff --git a/src/proc/mobject/session/binding.cpp b/src/proc/mobject/session/binding.cpp index 5451f59d3..acc6dee79 100644 --- a/src/proc/mobject/session/binding.cpp +++ b/src/proc/mobject/session/binding.cpp @@ -44,7 +44,7 @@ namespace session { return true; // Ideas: - compare the bound sequence's channels with this binding's channel configuration // - verify the virtual media, unless this biding is creating a top-level timeline - // - verify the bound sequence is based on a track within the model + // - verify the bound sequence is based on a fork within the model } diff --git a/src/proc/mobject/session/fixedlocation.hpp b/src/proc/mobject/session/fixedlocation.hpp index 531669ded..cab2b0698 100644 --- a/src/proc/mobject/session/fixedlocation.hpp +++ b/src/proc/mobject/session/fixedlocation.hpp @@ -40,17 +40,17 @@ namespace mobject { * in the Session: directly specifying a constant position. * @todo use a subclass to represent the LocatingSolution? * would solve the construction of a ExplicitPlacement - * much more natural. (ichthyo: siehe trac #100) + * much more natural. //////////TICKET #100 */ class FixedLocation : public LocatingPin { Time time_; - Track track_; + Fork fork_; - friend class ExplicitPlacement; //TODO trac #100 + friend class ExplicitPlacement; //////////////////////TICKET #100 protected: - FixedLocation (Time ti, Track tra) : time_(ti), track_(tra) {}; + FixedLocation (Time ti, Fork fo) : time_(ti), fork_(fo) {}; friend class LocatingPin; virtual void intersect (LocatingSolution&) const; diff --git a/src/proc/mobject/session/fork.cpp b/src/proc/mobject/session/fork.cpp index 6f20581e1..c5e800b19 100644 --- a/src/proc/mobject/session/fork.cpp +++ b/src/proc/mobject/session/fork.cpp @@ -28,22 +28,25 @@ namespace proc { namespace mobject { namespace session { - /** create a new track-MObject based on the given unique ID. - * Initially, the reference (zero-point) time of this track - * will be set to 0 + /** create a new fork-MObject based on the given unique ID. + * While the fork is an MObject attached locally within the + * given Sequence, it referres to a globally known forkID, + * which is an Asset. These fork-IDs might be shared among + * several Sequences and can be used to refer to several + * scopes simultaneously. */ - Track::Track (TrackID const& trackID) + Fork::Fork (ForkID const& forkID) : start_(Time::ZERO) //////////////////////////////////TODO something more inspired please - , id_(trackID) + , id_(forkID) { throwIfInvalid(); } bool - Track::isValid() const + Fork::isValid() const { - return bool(id_.isValid()); ////////TODO anything more 'real' to check? + return bool(id_.isValid()); ////////TODO anything more to check 'for real'? } diff --git a/src/proc/mobject/session/fork.hpp b/src/proc/mobject/session/fork.hpp index 6a1124f55..358b74f86 100644 --- a/src/proc/mobject/session/fork.hpp +++ b/src/proc/mobject/session/fork.hpp @@ -37,50 +37,55 @@ namespace session { //////////////////////////////////////////////////////TI using lib::P; using lib::time::Time; - class Track; + class Fork; - typedef P PTrack; + typedef P PFork; }} namespace asset { //////////////////////////////////////////////////////TICKET #637 - typedef EntryID TrackID; + typedef EntryID ForkID; } namespace mobject { namespace session { - using asset::TrackID; + using asset::ForkID; //////////////////////////////////////////////////////TICKET #646 //////////////////////////////////////////////////////TICKET #715 /** - * A Track is grouping device within the Session. - * The corresponding Placement by which this Track object is referred - * defines fallback placing properties to be used by all objects placed on this track - * in case they don't specify more concrete placements. - * Typically, tracks are used do make default processing pipe connections, - * define a layer or pan for sound and for for disabling groups - * of clips. Note tracks are grouped in a tree like fashion. + * A Fork serves as grouping device within the Session. + * Within the timeline, forks are used to organise continuous trails of consecutive + * clips -- similar to the role of "Tracks" in other editing applications. Just, in + * Lumiera a Fork is \em only a grouping device and not limited just to video or audio. + * Moreover, Forks are also used to organise and group clips in preparation to editing + * (the so called "media bins"). And forks can be used to create assortments of effects + * and other editing tools. In all these cases, the Fork creates a \em scope. + * + * The corresponding Placement by which this Fork object is attached to the session + * defines fallback placing properties to be used by all objects placed within the + * scope of this fork, unless individual objects specify more concrete placements. + * Typically, the placement within a fork of the timeline is used to derive the + * default processing pipe connections, define a layer or pan for sound and also + * for for disabling groups of clips. But note that forks are always nested, + * forming a tree like grouping device with hierarchically nested scopes. * \par - * This Media Object (often referred to as "track-MO") is always dealt with + * This Fork Media Object (sometimes referred to as "fork-MO") is always dealt with * locally within one Sequence. Client code normally doesn't have to care for creating - * or retrieving track-MO. Rather, it refers to the global track-asset-ID. The same - * holds true when placing some other Media Object onto a track: the corresponding - * placement just refers the global trackID, while the builder automatically retrieves the - * matching track-MO for the Sequence in question. If the Session contains several instances - * (track-MO) referring to the same trackID (asset), then this causes all objects placed - * onto this track to be included several times in the resulting render nodes network - * (possibly with varying placement properties) //////////////TODO 3/2010 likely *not* implementing this feature, because we have sequences + * or retrieving a fork-MO. Rather, it refers to the global fork-asset-ID. The same + * holds true when placing some other Media Object into the scope of a fork: + * the corresponding placement just refers the global forkID, while the builder + * automatically retrieves the matching fork-MO for the Sequence in question. */ - class Track : public Meta + class Fork : public Meta { Time start_; /////////////////////////////////TODO: this doesn't belong here. The start position is governed by the Placement!!! - TrackID id_; + ForkID id_; string @@ -92,7 +97,7 @@ namespace session { bool isValid() const; protected: - Track (TrackID const&); + Fork (ForkID const&); friend class MObjectFactory; public: @@ -106,7 +111,7 @@ namespace session { inline bool - Track::isSameID(string const& refID) + Fork::isSameID(string const& refID) { return refID == id_.getSym(); } @@ -114,9 +119,9 @@ namespace session { } // namespace mobject::session - /** Placement defined to be subclass of Placement */ - template class Placement; - typedef Placement PTrack; + /** Placement defined to be subclass of Placement */ + template class Placement; + typedef Placement PFork; }} // namespace proc::mobject #endif /*MOBJECT_SESSION_FORK_H*/ diff --git a/src/proc/mobject/session/locatingpin.cpp b/src/proc/mobject/session/locatingpin.cpp index 93f6437e5..7a79a7777 100644 --- a/src/proc/mobject/session/locatingpin.cpp +++ b/src/proc/mobject/session/locatingpin.cpp @@ -182,7 +182,7 @@ namespace session { /* === Factory functions for adding LocatingPins === */ FixedLocation& - LocatingPin::operator() (Time start, Track track) + LocatingPin::operator() (Time start, Fork track) /////////////TODO "track" should be reworked to be the output designation { return static_cast (addChain (new FixedLocation (start, track))); diff --git a/src/proc/mobject/session/locatingpin.hpp b/src/proc/mobject/session/locatingpin.hpp index 33b9bfedb..b74df98e2 100644 --- a/src/proc/mobject/session/locatingpin.hpp +++ b/src/proc/mobject/session/locatingpin.hpp @@ -101,7 +101,7 @@ namespace mobject { typedef lib::time::Time Time; typedef lib::time::TimeVar TimeVar; typedef lib::time::Offset Offset; - typedef Time* Track; //TODO dummy declaration; we don't use Tracks as first-class entity any longer + typedef Time* Fork; //TODO dummy declaration; we don't use Tracks as first-class entity any longer. This role should be taken by the "Output Designation" typedef std::shared_ptr Pipe; typedef std::pair SolutionData; //TICKET #100 (ichthyo considers better passing of solution by subclass) struct LocatingSolution; @@ -122,7 +122,7 @@ namespace mobject { /* Factory functions for adding LocatingPins */ - FixedLocation& operator() (Time start, Track track=0); + FixedLocation& operator() (Time start, Fork track=0); //////////TODO: Tracks are gone, long live the Forks! RelativeLocation& operator() (PlacementRef& refObj, Offset const& offset=Offset(Time::ZERO)); //////////TODO: warning, just a dummy placeholder for now!! LocatingPin (const LocatingPin&); @@ -151,8 +151,8 @@ protected: { TimeVar minTime; TimeVar maxTime; - Track minTrack; // TODO don't use Tracks - Track maxTrack; + Fork minTrack; // TODO don't use Tracks + Fork maxTrack; bool impo; LocatingSolution () diff --git a/src/proc/mobject/session/mobjectfactory.cpp b/src/proc/mobject/session/mobjectfactory.cpp index e24472cb2..2a03d3224 100644 --- a/src/proc/mobject/session/mobjectfactory.cpp +++ b/src/proc/mobject/session/mobjectfactory.cpp @@ -64,7 +64,7 @@ namespace session { * internally and wrapped into a Placement, which takes ownership. * So, when the render engine gets across this Clip-MO, it is able * to obtain the media information contained in the corresponding - * media asset. Note this will create a single track clip. + * media asset. * @param mediaDef the actual asset::Media to be used * created Clip could be a compound (multichannel) clip * comprised of several SimpleClip sub-objects. @@ -85,13 +85,13 @@ namespace session { UNIMPLEMENTED ("build multichannel compound clip-MO"); } - /** fabricate a new track-MObject, using the given unique ID */ - Placement - MObjectFactory::operator() (TrackID const& id) + /** fabricate a new fork-MObject, using the given unique ID */ + Placement + MObjectFactory::operator() (ForkID const& id) { - TODO ("what needs to be registered when creating an Track-MO?"); - TODO ("assure the ID is indeed unique and not already used for another track"); //////////TICKET #638 - return Placement (*new Track (id), &deleterFunc); + TODO ("what needs to be registered when creating an Fork-MO?"); + TODO ("assure the ID is indeed unique and not already used for another fork??"); //////////TICKET #638 + return Placement (*new Fork (id), &deleterFunc); } /** */ diff --git a/src/proc/mobject/session/mobjectfactory.hpp b/src/proc/mobject/session/mobjectfactory.hpp index 7eb55dc91..b10d4fdc4 100644 --- a/src/proc/mobject/session/mobjectfactory.hpp +++ b/src/proc/mobject/session/mobjectfactory.hpp @@ -51,7 +51,7 @@ namespace session { class Root; class Clip; - class Track; + class Fork; class Effect; class Label; class Binding; @@ -70,7 +70,7 @@ namespace session { Placement operator() (lumiera::query::DefsManager&); Placement operator() (asset::Clip const&, asset::Media const&); Placement operator() (asset::Clip const&, vector); - Placement operator() (asset::EntryID const&); + Placement operator() (asset::EntryID const&); Placement operator() (asset::Effect const&); Placement