Loading...
Searching...
No Matches
Classes | Typedefs | Enumerations | Functions | Variables
Scenario Namespace Reference

Main plug-in of score. More...

Detailed Description

Main plug-in of score.

This plug-in introduces the central logic of score : a hierarchical model of objects in a timeline.

It also has the core graphics logic of score based on QGraphicsScene and QGraphicsView.

As such, it is quite complex and provides a lot of classes.

We have :

Classes

class  AddProcessDialog
 
struct  AddressAccessorCurveCreator
 
class  AddressBarWidget
 Clickable path of the interval shown in the central view. More...
 
class  AmovibleSlotFooter
 
class  AutomationDropHandler
 The AutomationDropHandler class Will create an automation where the addresses are dropped. More...
 
class  BaseElementContext
 
class  BaseScenario
 
class  BaseScenarioContainer
 
class  BaseScenarioDisplayedElementsProvider
 
class  BaseScenarioDisplayedElementsToolPalette
 
class  BaseScenarioDisplayedElementsToolPaletteFactory
 
class  BaseScenarioIntervalResizer
 
struct  CategorisedScenario
 
struct  CategorizedAddress
 
struct  CategorizedAddresses
 
class  CentralIntervalDisplay
 
class  CentralNodalDisplay
 
class  ChangePortsCommandFactory
 Sets controls that change the ports of their process with SetControllerControlValue. More...
 
class  ClickOnEndEvent_Transition
 
class  ClickOnEndState_Transition
 
class  ClickOnEndTimeSync_Transition
 
struct  ClickOnSlotHandle_Event
 
class  ClickOnSlotHandle_Transition
 
class  CoherencyCheckerFactoryInterface
 
class  CommentBlockModel
 
class  CommentBlockPresenter
 
class  CommentBlockView
 
class  CommentEdit
 
class  CommonDisplacementPolicy
 The displacementPolicy class This class allows to implement multiple displacement behaviors. More...
 
class  ConditionView
 
class  ConstrainedDisplacementPolicy
 
struct  ContextMenuCallback
 
struct  CopiedCables
 
struct  CopiedPaths
 Paths of the copied objects and of their copies. More...
 
class  Creation_FromEvent
 
class  Creation_FromNothing
 
class  Creation_FromState
 
class  Creation_FromTimeSync
 
class  CreationState
 
class  CreationStateBase
 
class  CreationTool
 
class  CrossOverlay
 
class  CSPCoherencyCheckerInterface
 
class  CSPCoherencyCheckerList
 
struct  CurveCreator
 
struct  CycleDetector
 
class  DefaultDisplayedElementsProvider
 
struct  DisplayedElementsContainer
 
class  DisplayedElementsModel
 
class  DisplayedElementsPresenter
 
struct  DisplayedElementsPresenterContainer
 
class  DisplayedElementsProvider
 
class  DisplayedElementsProviderList
 
class  DisplayedElementsToolPaletteFactory
 
class  DisplayedElementsToolPaletteFactoryList
 
class  DoNotMoveInterval_StateWrapper
 
class  DropHandler
 
class  DropHandlerList
 
class  DropLayerInInterval
 
class  DropLayerInScenario
 
class  DropOnCable
 
class  DropOnNode
 
class  DropPresetInInterval
 
class  DropPresetInScenario
 
class  DropProcessInInterval
 
class  DropProcessInIntervalHelper
 
class  DropProcessInScenario
 
class  DropProcessInScenarioHelper
 
class  DropProcessOnState
 
class  DropProcessOnStateHelper
 
class  DropScenario
 
class  DropScoreInInterval
 What happens when a .score file is dropped in an interval. More...
 
class  DropScoreInScenario
 
class  DurationWidget
 
class  EditionGrid
 
class  EditionSettings
 
class  EditScript
 
struct  ElementsProperties
 
struct  ElementTraits
 
struct  ElementTraits< BaseScenarioContainer, EventModel >
 
struct  ElementTraits< BaseScenarioContainer, IntervalModel >
 
struct  ElementTraits< BaseScenarioContainer, StateModel >
 
struct  ElementTraits< BaseScenarioContainer, TimeSyncModel >
 
struct  ElementTraits< Scenario::ScenarioInterface, EventModel >
 
struct  ElementTraits< Scenario::ScenarioInterface, IntervalModel >
 
struct  ElementTraits< Scenario::ScenarioInterface, StateModel >
 
struct  ElementTraits< Scenario::ScenarioInterface, TimeSyncModel >
 
class  EnableWhenScenarioInterfaceInstantObject
 Only events, nodes, states. More...
 
class  EnableWhenScenarioInterfaceObject
 Anything in a scenario interface. More...
 
class  EnableWhenScenarioModelObject
 Anything in a scenario model. More...
 
struct  EncapsData
 
struct  EndDateComparator
 
class  EventActions
 
class  EventInspectorWidget
 The EventInspectorWidget class Inherits from InspectorWidgetInterface. More...
 
class  EventModel
 
class  EventPresenter
 
class  EventShortCut
 
class  EventSummaryWidget
 
class  EventView
 
struct  ExecutionStatusProperty
 
class  ExpressionEditorWidget
 
class  ExpressionMenu
 
class  FixedHandle
 
class  FixedSlotFooter
 
struct  FullSlot
 
class  FullViewIntervalHeader
 
class  FullViewIntervalPresenter
 
class  FullViewIntervalView
 
struct  get_curve_domain
 Automation range between two values, widened to the target address's domain. More...
 
struct  get_start_end
 
class  GhostIntervalDropHandler
 
class  GoodOldDisplacementPolicy
 
class  GraphalIntervalPresenter
 
class  InspectorWidgetDelegateFactory
 
class  IntervalActions
 
class  IntervalBrace
 
class  IntervalComponent
 
class  IntervalDropHandler
 
class  IntervalDropHandlerList
 
class  IntervalDurations
 
class  IntervalHeader
 
class  IntervalInspectorFactory
 
class  IntervalInspectorWidget
 The IntervalInspectorWidget class. More...
 
class  IntervalModel
 
struct  IntervalPixmaps
 
class  IntervalPresenter
 
struct  IntervalProperties
 
class  IntervalResizer
 
class  IntervalResizerList
 
struct  IntervalSaveData
 
class  IntervalSummaryWidget
 
class  IntervalView
 
class  ItemType
 
class  LayerData
 
class  LayerRectItem
 
struct  LayerSlotPresenter
 
class  LeftBraceView
 
class  LightBars
 
class  LighterBars
 
class  LineTextItem
 
struct  MagneticStates
 
class  MatchedTransition
 
class  MessageDropHandler
 The MessageDropHandler class Will create a state in the scenario at the point a MessageList is dropped. More...
 
class  MessageItemModel
 The MessageItemModel class. More...
 
class  MessageListProxy
 
class  MessageTreeView
 
class  MetadataWidget
 
class  Minimap
 
class  MinimapGraphicsView
 
class  MiniScenarioView
 
class  ModelConsistency
 
class  MovableHandle
 
class  MoveEventInBaseScenario_StateWrapper
 
class  MoveEventInScenario_StateWrapper
 
class  MoveEventInTopScenario_StateWrapper
 
class  MoveEventState
 
class  MoveIntervalBraceState
 
class  MoveIntervalInScenario_StateWrapper
 
class  MoveIntervalState
 
class  MoveLeftBraceInScenario_StateWrapper
 
class  MoveOnAnything_SlotTransition
 
class  MoveOnAnything_Transition
 
class  MoveOnAnythingButEvent_Transition
 
class  MoveOnAnythingButPonctual_Transition
 
class  MoveOnAnythingButTimeSync_Transition
 
struct  MoveOnSlotHandle_Event
 
class  MoveOnSlotHandle_Transition
 
class  MoveRightBraceInScenario_StateWrapper
 
class  MoveTimeSyncInBaseScenario_StateWrapper
 
class  MoveTimeSyncInScenario_StateWrapper
 
class  MoveTimeSyncInTopScenario_StateWrapper
 
class  MoveTimeSyncState
 
class  MusicalGrid
 
class  MusicalRuler
 
class  NeighbourSelector
 
struct  NodalContainer
 
class  NodalIntervalView
 
struct  NodalSlotPresenter
 
class  ObjectItemModel
 
struct  ObjectMapper
 
class  ObjectMenuActions
 
class  ObjectPanelDelegate
 
class  ObjectPanelDelegateFactory
 
class  ObjectWidget
 
struct  OutletRouting
 
struct  ParentTimeInfo
 
struct  PathDetector
 
struct  PathDetectorState
 
class  PlayToolState
 
struct  Point
 
struct  PositionedScenarioEvent
 
struct  PositionedWithId_ScenarioEvent
 
struct  PresetDropChoices
 
class  ProcessDataDropHandler
 
struct  ProcessesBeingCopied
 
class  ProcessGraphicsView
 
class  ProcessItem
 
class  ProcessModel
 The core hierarchical and temporal process of score. More...
 
class  ProcessStateWrapper
 
class  PutLayerModelToFront
 
class  ReleaseOnAnything_SlotTransition
 
class  ReleaseOnAnything_Transition
 
struct  ReleaseOnSlotHandle_Event
 
class  ReleaseOnSlotHandle_Transition
 
struct  RequestOverlayMenuCallback
 
class  ResizeSlotState
 
class  RightBraceView
 
class  ScenarioApplicationPlugin
 
struct  ScenarioBeingCopied
 
class  ScenarioContextMenuManager
 
class  ScenarioCreate
 
class  ScenarioCreate< CommentBlockModel >
 
class  ScenarioCreate< EventModel >
 
class  ScenarioCreate< IntervalModel >
 
class  ScenarioCreate< StateModel >
 
class  ScenarioCreate< TimeSyncModel >
 
class  ScenarioDisplayedElementsProvider
 
class  ScenarioDisplayedElementsToolPalette
 
class  ScenarioDisplayedElementsToolPaletteFactory
 
class  ScenarioDocumentFactory
 
class  ScenarioDocumentModel
 
class  ScenarioDocumentPresenter
 The ScenarioDocumentPresenter class. More...
 
class  ScenarioDocumentView
 
class  ScenarioEditor
 
class  ScenarioExecution
 API for the various elements that we can execute. More...
 
class  ScenarioInspectorWidgetFactoryWrapper
 
class  ScenarioInterface
 
class  ScenarioIntervalResizer
 
class  ScenarioLibraryHandler
 
class  ScenarioPresenter
 
struct  ScenarioRecordInitData
 
class  ScenarioRecursiveFind
 
class  ScenarioScene
 
class  ScenarioTemporalLayerFactory
 
class  ScenarioValidityChecker
 
class  ScenarioView
 
class  ScenarioViewInterface
 
class  ScrubHandler
 
class  SearchReplaceWidget
 
class  SearchWidget
 
struct  SelectedNodes
 
class  SelectionStackWidget
 
class  SelectionState
 
class  SetControllerControlValue
 
class  SimpleComboBox
 
class  SimpleExpressionEditorWidget
 
class  SizePolicyWidget
 
struct  Slot
 
class  SlotDragOverlay
 
class  SlotFooter
 
class  SlotHeader
 
struct  SlotId
 
class  SlotLibraryHandler
 
struct  SlotPath
 
struct  SlotPresenter
 
class  SlotState
 
class  SmartTool
 
struct  SnapshotAction
 
class  SnapshotStatesMacro
 
class  SpeedWidget
 
struct  StartDateComparator
 
class  StartMarker
 
class  StateBase
 
class  StateGraphPlusOverlay
 
class  StateInspectorWidget
 
class  StateModel
 
struct  StateOverlays
 
class  StatePlusOverlay
 
class  StatePresenter
 
class  StateSequencePlusOverlay
 
class  StateView
 
class  StrongQState
 
class  SummaryInspectorWidget
 
class  TempoPointInspectorFactory
 
class  TempoPointInspectorWidget
 
class  TempoPresenter
 
class  TemporalIntervalHeader
 
class  TemporalIntervalPresenter
 
class  TemporalIntervalView
 
class  TempoView
 
class  TextDialog
 
struct  Timebars
 
struct  TimenodeGraph
 
struct  TimenodeGraphComponents
 
struct  TimenodeGraphConnectedComponent
 A directed graph of all the TimeSyncs in a ScenarioInterface. More...
 
struct  TimenodeProperties
 
class  TimeRuler
 
class  TimeRulerBase
 
class  TimeRulerGraphicsView
 
class  TimeSignatureHandle
 
class  TimeSignatureItem
 
struct  TimeSignatureMap
 
class  TimeSyncInspectorWidget
 The TimeSyncInspectorWidget class Inherits from InspectorWidgetInterface. More...
 
class  TimeSyncModel
 
class  TimeSyncPresenter
 
class  TimeSyncSummaryWidget
 
class  TimeSyncView
 
class  ToolBase
 
class  ToolMenuActions
 
class  ToolPalette
 
class  Transition_T
 
class  Transition_T< Scenario_T, ClickOnEvent >
 
class  Transition_T< Scenario_T, ClickOnInterval >
 
class  Transition_T< Scenario_T, ClickOnLeftBrace >
 
class  Transition_T< Scenario_T, ClickOnNothing >
 
class  Transition_T< Scenario_T, ClickOnRightBrace >
 
class  Transition_T< Scenario_T, ClickOnState >
 
class  Transition_T< Scenario_T, ClickOnTimeSync >
 
class  Transition_T< Scenario_T, MoveOnEvent >
 
class  Transition_T< Scenario_T, MoveOnInterval >
 
class  Transition_T< Scenario_T, MoveOnNothing >
 
class  Transition_T< Scenario_T, MoveOnState >
 
class  Transition_T< Scenario_T, MoveOnTimeSync >
 
class  Transition_T< Scenario_T, ReleaseOnEvent >
 
class  Transition_T< Scenario_T, ReleaseOnNothing >
 
class  Transition_T< Scenario_T, ReleaseOnState >
 
class  Transition_T< Scenario_T, ReleaseOnTimeSync >
 
class  TransportActions
 
class  TriggerInspectorWidget
 
class  TriggerView
 
struct  value_size
 
class  ValueItemDelegate
 Gives a value column the Device Explorer's editors. More...
 
struct  VerticalExtent
 The VerticalExtent struct. More...
 
class  ZPos
 

Typedefs

using SavedPort = Dataflow::SavedPort
 
template<typename System_T >
using GenericIntervalComponent = Scenario::IntervalComponent< score::GenericComponent< System_T > >
 
using GraphVertex = Scenario::TimeSyncModel *
 
using GraphEdge = Scenario::IntervalModel *
 
using Graph = boost::directed_graph< GraphVertex, GraphEdge >
 
using Rack = std::vector< Slot >
 
using FullRack = std::vector< FullSlot >
 
using TimeSignatureMapDtlVector = std::vector< boost::container::dtl::pair< TimeVal, ossia::time_signature > >
 
using TimeSignatureMapStdVector = std::vector< std::pair< TimeVal, ossia::time_signature > >
 
using TimeSignatureFlatMap = boost::container::flat_map< TimeVal, ossia::time_signature, std::less< TimeVal >, TimeSignatureMapStdVector >
 
using TimeSignatureFlatMapImpl = std::remove_cvref_t< decltype(TimeSignatureFlatMap{}.tree().get_sequence_cref())>
 
using CentralDisplay = ossia::slow_variant< ossia::monostate, CentralIntervalDisplay, CentralNodalDisplay >
 
using TempoFactory = Process::ProcessFactory_T< Scenario::TempoProcess >
 
using TempoLayerFactory = Curve::CurveLayerFactory_T< Scenario::TempoProcess, Scenario::TempoPresenter, Scenario::TempoView, Automation::Colors, Process::DefaultHeaderDelegate >
 
using ClickOnNothing_Event = PositionedScenarioEvent< ClickOnNothing >
 
using ClickOnTimeSync_Event = PositionedWithId_ScenarioEvent< TimeSyncModel, ClickOnTimeSync >
 
using ClickOnEvent_Event = PositionedWithId_ScenarioEvent< EventModel, ClickOnEvent >
 
using ClickOnInterval_Event = PositionedWithId_ScenarioEvent< IntervalModel, ClickOnInterval >
 
using ClickOnState_Event = PositionedWithId_ScenarioEvent< StateModel, ClickOnState >
 
using ClickOnTrigger_Event = score::NumberedWithPath_Event< TriggerModel, ClickOnTrigger >
 
using ClickOnLeftBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, ClickOnLeftBrace >
 
using ClickOnRightBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, ClickOnRightBrace >
 
using MoveOnNothing_Event = PositionedScenarioEvent< MoveOnNothing >
 
using MoveOnTimeSync_Event = PositionedWithId_ScenarioEvent< TimeSyncModel, MoveOnTimeSync >
 
using MoveOnEvent_Event = PositionedWithId_ScenarioEvent< EventModel, MoveOnEvent >
 
using MoveOnInterval_Event = PositionedWithId_ScenarioEvent< IntervalModel, MoveOnInterval >
 
using MoveOnState_Event = PositionedWithId_ScenarioEvent< StateModel, MoveOnState >
 
using MoveOnTrigger_Event = score::NumberedWithPath_Event< TriggerModel, MoveOnTrigger >
 
using MoveOnLeftBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, MoveOnLeftBrace >
 
using MoveOnRightBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, MoveOnRightBrace >
 
using ReleaseOnNothing_Event = PositionedScenarioEvent< ReleaseOnNothing >
 
using ReleaseOnTimeSync_Event = PositionedWithId_ScenarioEvent< TimeSyncModel, ReleaseOnTimeSync >
 
using ReleaseOnEvent_Event = PositionedWithId_ScenarioEvent< EventModel, ReleaseOnEvent >
 
using ReleaseOnInterval_Event = PositionedWithId_ScenarioEvent< IntervalModel, ReleaseOnInterval >
 
using ReleaseOnState_Event = PositionedWithId_ScenarioEvent< StateModel, ReleaseOnState >
 
using ReleaseOnTrigger_Event = score::NumberedWithPath_Event< TriggerModel, ReleaseOnTrigger >
 
using ReleaseOnLeftBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, ReleaseOnLeftBrace >
 
using ReleaseOnRightBrace_Event = PositionedWithId_ScenarioEvent< IntervalModel, ReleaseOnRightBrace >
 
template<typename Scenario_T , typename T >
using GenericTransition = score::StateAwareTransition< Scenario::StateBase< Scenario_T >, T >
 
template<typename Scenario_T >
using ClickOnEvent_Transition = Transition_T< Scenario_T, ClickOnEvent >
 
template<typename Scenario_T >
using MoveOnEvent_Transition = Transition_T< Scenario_T, MoveOnEvent >
 
template<typename Scenario_T >
using ReleaseOnEvent_Transition = Transition_T< Scenario_T, ReleaseOnEvent >
 
template<typename Scenario_T >
using ClickOnInterval_Transition = Transition_T< Scenario_T, ClickOnInterval >
 
template<typename Scenario_T >
using MoveOnInterval_Transition = Transition_T< Scenario_T, MoveOnInterval >
 
template<typename Scenario_T >
using ClickOnLeftBrace_Transition = Transition_T< Scenario_T, ClickOnLeftBrace >
 
template<typename Scenario_T >
using ClickOnRightBrace_Transition = Transition_T< Scenario_T, ClickOnRightBrace >
 
template<typename Scenario_T >
using ClickOnNothing_Transition = Transition_T< Scenario_T, ClickOnNothing >
 
template<typename Scenario_T >
using MoveOnNothing_Transition = Transition_T< Scenario_T, MoveOnNothing >
 
template<typename Scenario_T >
using ReleaseOnNothing_Transition = Transition_T< Scenario_T, ReleaseOnNothing >
 
template<typename Scenario_T >
using ClickOnState_Transition = Transition_T< Scenario_T, ClickOnState >
 
template<typename Scenario_T >
using MoveOnState_Transition = Transition_T< Scenario_T, MoveOnState >
 
template<typename Scenario_T >
using ReleaseOnState_Transition = Transition_T< Scenario_T, ReleaseOnState >
 
template<typename Scenario_T >
using ClickOnTimeSync_Transition = Transition_T< Scenario_T, ClickOnTimeSync >
 
template<typename Scenario_T >
using MoveOnTimeSync_Transition = Transition_T< Scenario_T, MoveOnTimeSync >
 
template<typename Scenario_T >
using ReleaseOnTimeSync_Transition = Transition_T< Scenario_T, ReleaseOnTimeSync >
 
using ScenarioFactory = Process::ProcessFactory_T< Scenario::ProcessModel >
 

Enumerations

enum class  PresetDrop { Controls , ControlsAndState , Copy }
 
enum class  OffsetBehavior : int8_t { True , False , Expression }
 
enum class  ExecutionStatus : int8_t {
  Waiting , Pending , Happened , Disposed ,
  Editing
}
 
enum class  IntervalExecutionState : uint8_t { Enabled = 0 , Disabled = 1 , Muted = 2 }
 
enum class  IntervalExecutionEvent : uint8_t {
  Enabled , Disabled , Muted , Unmuted ,
  Playing , Stopped , Paused , Resumed ,
  Finished
}
 
enum class  ProcessPosition { Previous , Following }
 
enum  ExpressionEditorComparator {
  Equal , Different , Greater , Lower ,
  GreaterEqual , LowerEqual , Contains , Pulse ,
  AlwaysTrue , AlwaysFalse
}
 
enum  ScenarioElement {
  Nothing , TimeSync , Event , Interval ,
  State , SlotOverlay_e , SlotHandle_e , Trigger ,
  LeftBrace , RightBrace
}
 
enum class  Tool : uint8_t {
  Disabled , Create , CreateGraph , CreateSequence ,
  Select , Play , Playing
}
 

Functions

rapidjson::Value * draggedCopy (rapidjson::Value &json)
 The copy carried by a drag from the processes' preset button, or nullptr.
 
bool isProcessesDrag (const QMimeData &mime)
 Such drags go to the layer handlers, not the preset ones.
 
std::vector< const Process::ProcessModel * > draggedProcesses (const rapidjson::Value &json, const score::DocumentContext &ctx)
 The current processes of this document that such a drag refers to.
 
const StateModel & createCueState (Scenario::Command::Macro &m, const ScenarioPresenter &pres, QPointF pos, MagneticStates &magneticState)
 
PresetDropChoices presetDropChoices (const std::vector< const Process::ProcessModel * > &processes, bool copy, bool withState=true)
 withState serializes the processes to find whether they have a state.
 
std::optional< PresetDrop > choosePresetDrop (const std::vector< const Process::ProcessModel * > &processes, bool copy)
 With Ctrl held, a menu at the cursor lists the choices; empty if dismissed.
 
bool dropStartsOnPlay () noexcept
 Whether the modifiers held during a drop ask for a start-on-play trigger.
 
void addStartOnPlayTrigger (Command::Macro &m, const TimeSyncModel &ts)
 Enable the trigger and start-on-play, like a double-click in a scenario does.
 
MagneticStates magneticStates (MagneticStates cur, Scenario::Point pt, const Scenario::ScenarioPresenter &pres)
 
auto selectedIntervalsInCurrentDocument (const score::GUIApplicationContext &appContext)
 
template<typename Scenario_T >
void copySelected (JSONReader &r, const Scenario_T &sm, CategorisedScenario &cs, QObject *parent)
 
void copySelectedScenarioElements (JSONReader &r, const Scenario::ProcessModel &sm, CategorisedScenario &cat)
 
void copyWholeScenario (JSONReader &r, const Scenario::ProcessModel &sm)
 
void copySelectedScenarioElements (JSONReader &r, const Scenario::ProcessModel &sm)
 
void copySelectedScenarioElements (JSONReader &r, const BaseScenarioContainer &sm, QObject *parent)
 
template<typename Vector >
std::vector< const typename Vector::value_type * > selectedElementsVec (const Vector &in)
 
void copySelectedElementsToJson (JSONReader &r, ScenarioInterface &si, const score::DocumentContext &ctx)
 
bool copySelectedProcesses (JSONReader &r, const score::DocumentContext &ctx)
 
void copyBaseInterval (JSONReader &, const IntervalModel &)
 
template<typename Data >
QAction * makeToolbarAction (const QString &name, QObject *parent, const Data &data, const QKeySequence &shortcut)
 
const ScenarioInterface * focusedScenarioInterface (const score::DocumentContext &ctx)
 
const ProcessModel * focusedScenarioModel (const score::DocumentContext &ctx)
 
void test_parse_expr_full ()
 
void CreateCurves (const std::vector< const Scenario::IntervalModel * > &selected_intervals, const score::CommandStackFacade &stack)
 
std::vector< Process::ProcessModel * > CreateCurvesFromAddress (const Scenario::IntervalModel &interval, const Device::FullAddressAccessorSettings &as, Scenario::Command::Macro &m)
 
int CreateCurvesFromAddresses (const Scenario::IntervalModel &interval, const Scenario::ScenarioInterface &scenar, const CategorizedAddresses &addresses, int N, Scenario::Command::Macro &m, std::vector< Process::ProcessModel * > &created)
 
std::vector< Process::ProcessModel * > CreateCurvesFromAddresses (const Scenario::IntervalModel &interval, const std::vector< Device::FullAddressSettings > &a, Scenario::Command::Macro &m)
 
std::vector< Process::ProcessModel * > CreateCurvesFromAddresses (const std::vector< const Scenario::IntervalModel * > &selected_intervals, const std::vector< Device::FullAddressSettings > &a, Scenario::Command::Macro &m)
 
void CreateCurvesFromAddresses (const std::vector< const Scenario::IntervalModel * > &selected_intervals, const std::vector< Device::FullAddressSettings > &a, const score::CommandStackFacade &stack)
 
template<typename Fun >
void DoForSelectedIntervals (const score::DocumentContext &doc, Fun f)
 
void SnapshotParametersInStates (const score::DocumentContext &doc)
 
double findSlotHeightByProcess (const IntervalModel &itv, const Process::ProcessModel &proc)
 
void DecapsulateScenario (const ProcessModel &scenar, const score::CommandStackFacade &stack)
 
void EncapsulateInScenario (const ProcessModel &scenar, const score::CommandStackFacade &stack)
 
void Duplicate (const ProcessModel &scenar, const score::CommandStackFacade &stack)
 
EncapsData EncapsulateElements (Scenario::Command::Macro &m, CategorisedScenario &cat, const ProcessModel &scenar)
 
bool copiedFromHere (const rapidjson::Value &copy, const score::DocumentContext &ctx)
 Compares the copy's "OriginDocument" key with score::IDocument::copyOrigin()
 
bool hasAnchors (const rapidjson::Value &copy)
 
void remapCopiedAnchors (QObject &root, const CopiedPaths &paths)
 
void followPasted (const score::DocumentContext &ctx, const std::vector< QObject * > &pasted)
 The copies are published under their own names.
 
std::vector< Process::CableData > cableDataFromCablesJson (const rapidjson::Document::ConstArray &arr)
 
std::vector< Process::CableData > cableDataFromCablesJson (const rapidjson::Document::Array &arr)
 
template<typename CopiedObjects , typename ParentObject >
ossia::flat_map< Id< Process::Cable >, Process::CableData > mapCopiedCables (const score::DocumentContext &ctx, std::vector< Process::CableData > &cables, std::vector< CopiedObjects * > &intervals, const std::vector< Id< CopiedObjects > > &interval_ids, const ParentObject &scenario)
 
const QVector< Id< IntervalModel > > intervalsBeforeTimeSync (const BaseScenario &scen, const Id< TimeSyncModel > &timeSyncId)
 
auto intervals (const BaseScenarioContainer &scenar)
 
auto events (const BaseScenarioContainer &scenar)
 
auto timeSyncs (const BaseScenarioContainer &scenar)
 
auto states (const BaseScenarioContainer &scenar)
 
const QPainterPath & startMarkerPath ()
 
void swap (Scenario::Slot &lhs, Scenario::Slot &rhs)
 
bool isInFullView (const IntervalModel &cstr) noexcept
 
bool isInFullView (const Process::ProcessModel &cstr) noexcept
 
bool isBus (const IntervalModel &model, const score::DocumentContext &ctx) noexcept
 
ParentTimeInfo closestParentWithMusicalMetrics (const IntervalModel *self)
 
ParentTimeInfo closestParentWithQuantification (const IntervalModel *self)
 
ParentTimeInfo closestParentWithTempo (const IntervalModel *self)
 
QSizeF nodeFootprint (const Process::ProcessModel &process) noexcept
 
QPointF freeProcessPosition (const IntervalModel &model, QPointF desired, QSizeF size, bool towardsRight, const Process::ProcessModel *ignore) noexcept
 
QPointF freeProcessPositionBelow (const IntervalModel &model, QPointF desired, QSizeF size, const Process::ProcessModel *ignore) noexcept
 
QPointF newProcessPosition (const IntervalModel &cst) noexcept
 
QPointF newProcessPositionAfter (const Scenario::IntervalModel &model, const Process::ProcessModel &previous) noexcept
 Position for a node created right after previous in the signal chain.
 
QPointF newProcessPositionBefore (const IntervalModel &model, const Process::ProcessModel &next, const Process::ProcessModel *created) noexcept
 
IntervalModel * closestParentInterval (const QObject *parentObj) noexcept
 
TimeVal timeDelta (const IntervalModel *self, const IntervalModel *parent)
 
IntervalPixmaps & intervalPixmaps (const Process::Style &style)
 
template<typename T >
const T::view_type * view (const T *obj)
 
template<typename T >
T::view_type * view (T *obj)
 
template<typename T >
T::view_type & view (const T &obj)
 
template<typename T >
T::view_type & view (T &obj)
 
Process::ProcessModel * closestParentProcessBeforeInterval (const QObject *obj)
 
const Process::Inlet * firstInletOfType (const Process::ProcessModel &proc, Process::PortType type) noexcept
 
const Process::Outlet * firstOutletOfType (const Process::ProcessModel &proc, Process::PortType type) noexcept
 
const Process::Outlet * firstSignalOutlet (const Process::ProcessModel &proc) noexcept
 
OutletRouting outletRouting (const Process::Outlet &p) noexcept
 
void applyOutletRouting (Command::Macro &m, const Process::Outlet &to, const OutletRouting &routing)
 
bool canInsertProcessInCable (const Process::Context &ctx, const Process::ProcessModel &proc, const Process::Cable &cbl)
 
void insertProcessInCable (score::Dispatcher &disp, const Process::Context &ctx, const Scenario::ScenarioDocumentModel &model, const Process::ProcessModel &proc, const Process::Cable &cbl)
 
void createProcessInCable (const Process::Context &context, const Scenario::ScenarioDocumentModel &model, const Process::ProcessData &dat, std::optional< TimeVal > tv, std::function< void(Process::ProcessModel &, score::Dispatcher &)> setup, const Process::Cable &cbl)
 
void loadPresetInCable (const Process::Context &context, const Scenario::ScenarioDocumentModel &model, const Process::Preset &dat, const Process::Cable &cbl)
 
void createProcessBeforePort (Scenario::ScenarioDocumentPresenter &parent, const Process::ProcessData &dat, std::optional< TimeVal > tv, std::function< void(Process::ProcessModel &, score::Dispatcher &)> setup, const Process::ProcessModel &parentProcess, const Process::Inlet &p)
 
void createProcessAfterPort (Scenario::ScenarioDocumentPresenter &parent, const Process::ProcessData &dat, std::optional< TimeVal > tv, std::function< void(Process::ProcessModel &, score::Dispatcher &)> setup, const Process::ProcessModel &parentProcess, const Process::Outlet &p, bool tryOtherOutlets)
 
void loadPresetBeforePort (Scenario::ScenarioDocumentPresenter &parent, const Process::Preset &dat, const Process::ProcessModel &parentProcess, const Process::Inlet &p)
 
void loadPresetAfterPort (Scenario::ScenarioDocumentPresenter &parent, const Process::Preset &dat, const Process::ProcessModel &parentProcess, const Process::Outlet &p, bool tryOtherOutlets)
 
QByteArray renderSceneToSvg (QGraphicsScene &scene, const QString &path, QRectF rect)
 
bool renderSceneToFile (QGraphicsScene &scene, const QString &path, QRectF rect)
 
std::vector< ObjectPath > loadCopiedProcesses (Scenario::Command::Macro &m, const Scenario::IntervalModel &interval, const rapidjson::Value &copy, std::vector< std::pair< int32_t, int32_t > > &proc_id_map, const score::DocumentContext &ctx)
 
void duplicateProcess (const IntervalModel &interval, const Process::ProcessModel &proc, const score::DocumentContext &ctx)
 Copies the process in its interval; references to its own objects move to the copy's.
 
bool pasteProcessesInNewBox (const Scenario::ProcessModel &sm, Scenario::Point origin, rapidjson::Value &obj, const score::DocumentContext &ctx, bool startsOnPlay)
 
QVariant valueColumnData (const MessageItemModel::node_type &node, int role)
 
Process::MessageNode * getNodeFromString_impl (Process::MessageNode &n, QStringList::const_iterator begin, QStringList::const_iterator end)
 
void updateTreeWithMessageList (Process::MessageNode &rootNode, State::MessageList lst)
 
void updateTreeWithMessageList (Process::MessageNode &rootNode, State::MessageList lst, const Id< Process::ProcessModel > &proc, ProcessPosition pos)
 
void updateTreeWithRemovedProcess (Process::MessageNode &rootNode, const Id< Process::ProcessModel > &proc, ProcessPosition pos)
 
void updateTreeWithRemovedInterval (Process::MessageNode &rootNode, ProcessPosition pos)
 
void updateTreeWithRemovedUserMessage (Process::MessageNode &rootNode, const State::AddressAccessor &addr)
 
void updateTreeWithRemovedNode (Process::MessageNode &rootNode, const State::AddressAccessor &addr)
 
void removeAllUserMessages (Process::MessageNode &rootNode)
 
int countNodes (Process::MessageNode &rootNode)
 
Process::MessageNode * getNthChild (Process::MessageNode &rootNode, int n)
 
int getChildIndex (Process::MessageNode &rootNode, Process::MessageNode *node)
 
void renameAddress (Process::MessageNode &rootNode, const State::AddressAccessor &oldAddr, const State::AddressAccessor &newAddr)
 
void findAndReplaceAddresses (Process::MessageNode &rootNode, const State::Address &oldAddr, const State::Address &newAddr)
 
void updateModelWithMessageList (MessageItemModel &model, State::MessageList lst)
 
void renameAddress (MessageItemModel &model, const State::AddressAccessor &oldAddr, const State::AddressAccessor &newAddr)
 
void updateModelWithMessageList (MessageItemModel &model, State::MessageList lst, const Id< Process::ProcessModel > &proc, ProcessPosition pos)
 
void updateModelWithRemovedProcess (MessageItemModel &model, const Id< Process::ProcessModel > &proc, ProcessPosition pos)
 
void updateModelWithRemovedInterval (MessageItemModel &model, ProcessPosition pos)
 
void updateModelWithRemovedUserMessage (MessageItemModel &model, const State::AddressAccessor &addr)
 
void updateModelWithRemovedNode (MessageItemModel &model, const State::AddressAccessor &addr)
 
void removeAllUserMessages (MessageItemModel &model)
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, smallNonDilated,([] { QPainterPath p;p.addEllipse({0, 0}, StateView::pointRadius, StateView::pointRadius);return p;}()))
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, fullNonDilated,([] { QPainterPath p;p.addEllipse({0, 0}, StateView::fullRadius, StateView::fullRadius);return p;}()))
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, fullProcessNonDilated,([] { QPainterPath p;p.addPolygon({ {0, StateView::fullRadius}, {StateView::fullRadius, 0}, {0, -StateView::fullRadius}, {-StateView::fullRadius, 0}, });return p;}()))
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, smallDilated,([] { QPainterPath p;p.addEllipse({0, 0}, StateView::pointRadius *StateView::dilated, StateView::pointRadius *StateView::dilated);return p;}()))
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, fullDilated,([] { QPainterPath p;p.addEllipse({0, 0}, StateView::fullRadius *StateView::dilated, StateView::fullRadius *StateView::dilated);return p;}()))
 
 Q_GLOBAL_STATIC_WITH_ARGS (QPainterPath, fullProcessDilated,([] { QPainterPath p;p.addPolygon({ {0, StateView::fullRadius *StateView::dilated}, {StateView::fullRadius *StateView::dilated, 0}, {0, -StateView::fullRadius *StateView::dilated}, {-StateView::fullRadius *StateView::dilated, 0}, });return p;}()))
 
void layoutTimeText (ossia::bar_time timings, ossia::bar_time increment, QTextLayout &layout)
 
template<class... Durations, class DurationIn >
std::tuple< Durations... > break_down_durations (DurationIn d)
 
void layoutTimeText (TimeRuler::Format format, QTextLayout &layout, std::chrono::nanoseconds t)
 
auto colorPalette () -> color_widgets::ColorPaletteModel &
 
template<typename T >
bool add_if_contains (const T &o, const QString &str, Selection &sel)
 
bool add_if_contains (const Scenario::CommentBlockModel &o, const QString &str, Selection &sel)
 
template<int N>
QString debug_StateMachineIDs ()
 
Point ConvertToScenarioPoint (const QPointF &point, ZoomRatio zoom, double height) noexcept
 
QPointF ConvertFromScenarioPoint (const Point &point, ZoomRatio zoom, double height) noexcept
 
constexpr bool isCreationTool (Tool t) noexcept
 
void doStateSelection (Selection &sel, const StateModel &m, const BaseScenario &model)
 
void doStateSelection (Selection &sel, const StateModel &m, const ProcessModel &model)
 
template<typename Scenario_T >
StateModel & startState (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
StateModel & endState (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
EventModel & startEvent (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
EventModel & endEvent (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
TimeSyncModel & startTimeSync (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
TimeSyncModel & endTimeSync (const IntervalModel &cst, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeSyncModel & parentTimeSync (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeSyncModel & parentTimeSync (const Id< EventModel > &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
const EventModel & parentEvent (const Id< StateModel > &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
const EventModel & parentEvent (const StateModel &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeSyncModel & parentTimeSync (const StateModel &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeSyncModel & parentTimeSync (const Id< StateModel > &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeSyncModel & parentTimeSync (const TimeSyncModel &st, const Scenario_T &)
 
template<typename Scenario_T >
const IntervalModel & previousInterval (const StateModel &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
const IntervalModel & nextInterval (const StateModel &st, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > nextIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > nextNonGraphIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > previousIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > previousNonGraphIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasPreviousIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasNextIntervals (const EventModel &ev, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasPreviousIntervals (const IntervalModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasNextIntervals (const IntervalModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool isSingular (const IntervalModel &itv, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > nextIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > nextNonGraphIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > previousIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< IntervalModel > > previousNonGraphIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasPreviousIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
bool hasNextIntervals (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Scenario_T >
std::list< Id< StateModel > > states (const TimeSyncModel &tn, const Scenario_T &scenario)
 
template<typename Element_T , typename Scenario_T >
const TimeVal & date (const Element_T &e, const Scenario_T &scenario)
 
template<typename Scenario_T >
const TimeVal & date (const IntervalModel &e, const Scenario_T &scenario)
 
template<typename Element_T >
Scenario::ScenarioInterface & parentScenario (Element_T &&e)
 
void AddProcess (IntervalModel &interval, Process::ProcessModel *proc)
 
void RemoveProcess (IntervalModel &interval, const Id< Process::ProcessModel > &proc_id)
 
void EraseProcess (IntervalModel &interval, const Id< Process::ProcessModel > &proc_id)
 
void SetPreviousInterval (StateModel &state, const IntervalModel &interval)
 
void SetNextInterval (StateModel &state, const IntervalModel &interval)
 
void SetNoPreviousInterval (StateModel &state)
 
void SetNoNextInterval (StateModel &state)
 
void updateTimeSyncExtent (TimeSyncPresenter &tn)
 
void updateEventExtent (ScenarioPresenter &pres, EventPresenter &ev, double view_height)
 
void updateIntervalVerticalPos (ScenarioPresenter &pres, IntervalModel &itv, double y, double view_height)
 
void clearContentFromSelection (const Scenario::ScenarioInterface &si, const score::DocumentContext &ctx)
 
void removeSelection (const Scenario::ProcessModel &scenario, const score::DocumentContext &ctx)
 
template<typename T >
auto make_ordered (const Scenario::ProcessModel &scenario)
 
void mergeTimeSyncs (const Scenario::ProcessModel &scenario, const score::CommandStackFacade &f)
 
void mergeEvents (const Scenario::ProcessModel &scenario, const score::CommandStackFacade &f)
 
void removeSelection (const BaseScenario &, const score::DocumentContext &ctx)
 
void removeSelection (const score::DocumentContext &ctx)
 
template<typename T >
auto startId ()
 
template<typename T >
auto endId ()
 
const QVector< Id< IntervalModel > > intervalsBeforeTimeSync (const Scenario::ProcessModel &scenar, const Id< TimeSyncModel > &timeSyncId)
 
Scenario::ProcessModel * closestParentScenario (const QObject *parentObj) noexcept
 
template<typename Scenario_T >
ossia::small_vector< StateModel *, 8 > getStates (const TimeSyncModel &ts, const Scenario_T &scenario)
 
const StateModel * furthestSelectedState (const Scenario::ProcessModel &scenar)
 
const EventModel * furthestSelectedEvent (const Scenario::ScenarioPresenter &scenar)
 
const TimeSyncModel * furthestSelectedSync (const Scenario::ScenarioPresenter &scenar)
 
const StateModel * furthestSelectedStateWithoutFollowingInterval (const Scenario::ProcessModel &scenar)
 
const TimeSyncModel * furthestHierarchicallySelectedTimeSync (const ScenarioPresenter &scenario)
 
std::vector< QObject * > findByAddress (const score::DocumentContext &ctx, const State::Address &root)
 
bool selectionHasScenarioElements (const Selection &sel)
 
template<typename T >
void update_min_max (const T &val, T &min, T &max)
 
double getNewLayerHeight (const score::ApplicationContext &ctx, const Process::ProcessModel &proc) noexcept
 
TimeVal getDate (const Scenario::ProcessModel &scenario, const Id< StateModel > &state)
 
TimeVal getDate (const Scenario::ProcessModel &scenario, const Id< EventModel > &event)
 
TimeVal getDate (const Scenario::ProcessModel &scenario, const Id< TimeSyncModel > &timesync)
 

Variables

std::function< std::optional< PresetDrop >(const PresetDropChoices &)> presetDropChooser
 Replaces choosePresetDrop when set.
 
const double deltaX = 10.
 
const double deltaY = FullViewTopMargin
 
constexpr double FullViewTopMargin = 24.
 Space kept above the full view interval, for the time signature bar.
 
constexpr double g_zoom_base = 1.2
 
constexpr int OssiaValueRole = Qt::UserRole + 41
 The row's value as an ossia::value.
 

Function Documentation

◆ canInsertProcessInCable()

bool Scenario::canInsertProcessInCable ( const Process::Context &  ctx,
const Process::ProcessModel &  proc,
const Process::Cable &  cbl 
)

Whether proc can be dropped on cbl: it has no cables yet and insertProcessInCable would connect at least one of its ports.

◆ copySelectedScenarioElements()

void Scenario::copySelectedScenarioElements ( JSONReader &  ,
const BaseScenarioContainer &  sm,
QObject *  parent 
)

The parent should be in the object tree of the scenario. This is because the StateModel needs access to the command stack of the document upon creation.

TODO instead we should follow the second part of this article : https://doc.qt.io/archives/qq/qq25-undo.html which explains how to use a proxy model to perform the undo - redo operations. This proxy model should be owned by the presenters where there is an easy and sensical access to the command stack

◆ createCueState()

SCORE_PLUGIN_SCENARIO_EXPORT const StateModel & Scenario::createCueState ( Scenario::Command::Macro &  m,
const ScenarioPresenter &  pres,
QPointF  pos,
MagneticStates &  magnetic 
)

Creates the state for a cue dropped at pos: on the event of the nearby state, at the end of an interval after it, or standalone.

◆ firstInletOfType()

const Process::Inlet * Scenario::firstInletOfType ( const Process::ProcessModel &  proc,
Process::PortType  type 
)
noexcept

First port of that type which carries signal flow: control ports are First port of that type, preferring signal ports over control ones.

◆ freeProcessPosition()

SCORE_PLUGIN_SCENARIO_EXPORT QPointF Scenario::freeProcessPosition ( const Scenario::IntervalModel &  model,
QPointF  desired,
QSizeF  size,
bool  towardsRight = true,
const Process::ProcessModel *  ignore = nullptr 
)
noexcept

Slides desired horizontally until a node of that size does not overlap any process of model. towardsRight picks the direction, so that a chain of processes keeps reading left-to-right.

◆ freeProcessPositionBelow()

SCORE_PLUGIN_SCENARIO_EXPORT QPointF Scenario::freeProcessPositionBelow ( const Scenario::IntervalModel &  model,
QPointF  desired,
QSizeF  size,
const Process::ProcessModel *  ignore = nullptr 
)
noexcept

Slides desired downwards until a node of that size does not overlap any process of model. The X is left where the caller put it, so a node chained after another one stays next to it however much is drawn further to the right.

◆ insertProcessInCable()

void Scenario::insertProcessInCable ( score::Dispatcher &  disp,
const Process::Context &  ctx,
const Scenario::ScenarioDocumentModel &  model,
const Process::ProcessModel &  proc,
const Process::Cable &  cbl 
)

Insert proc in cbl when it has both an inlet and an outlet of the cable's type; when only one end matches, leave the cable alone and just connect that end.

◆ loadCopiedProcesses()

std::vector< ObjectPath > Scenario::loadCopiedProcesses ( Command::Macro &  m,
const IntervalModel &  interval,
const rapidjson::Value &  copy,
std::vector< std::pair< int32_t, int32_t > > &  proc_id_map,
const score::DocumentContext &  ctx 
)

Loads copied processes in the interval, moving anchors between them to the copies; fills the old to new id mapping and returns the copies' paths.

◆ newProcessPositionBefore()

SCORE_PLUGIN_SCENARIO_EXPORT QPointF Scenario::newProcessPositionBefore ( const Scenario::IntervalModel &  model,
const Process::ProcessModel &  next,
const Process::ProcessModel *  created = nullptr 
)
noexcept

Position for a node created right before next in the signal chain. created is excluded from the overlap test as it already lives in the interval by the time its final position is known.

◆ nodeFootprint()

SCORE_PLUGIN_SCENARIO_EXPORT QSizeF Scenario::nodeFootprint ( const Process::ProcessModel &  process)
noexcept

Footprint used when placing nodes in the nodal view for a process whose on-screen size is not known yet (never displayed, or folded).

◆ pasteProcessesInNewBox()

bool Scenario::pasteProcessesInNewBox ( const Scenario::ProcessModel &  sm,
Scenario::Point  origin,
rapidjson::Value &  obj,
const score::DocumentContext &  ctx,
bool  startsOnPlay = false 
)

Pastes processes copied by copySelectedProcesses in a new interval at origin; startsOnPlay gives its start the trigger a double-click gives

◆ remapCopiedAnchors()

void Scenario::remapCopiedAnchors ( QObject &  root,
const CopiedPaths &  paths 
)

Anchors to a copied object move to its copy; others are kept only when pasting in the same document.

Variable Documentation

◆ OssiaValueRole

constexpr int Scenario::OssiaValueRole = Qt::UserRole + 41
inlineconstexpr

The row's value as an ossia::value.

The display and edit roles carry the value's text, which cannot tell a vec2f from a two-element list. A model whose value column offers this role gets typed editors from ValueItemDelegate.