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  AddressBarItem
 
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  ClickableLabelItem
 
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
 
class  ControlItemModel
 
struct  CopiedCables
 
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  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
 
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
 
class  NodalIntervalView
 
struct  NodalSlotPresenter
 
class  ObjectItemModel
 
struct  ObjectMapper
 
class  ObjectMenuActions
 
class  ObjectPanelDelegate
 
class  ObjectPanelDelegateFactory
 
class  ObjectWidget
 
struct  ParentTimeInfo
 
struct  PathDetector
 
struct  PathDetectorState
 
class  PlayToolState
 
struct  Point
 
struct  PositionedScenarioEvent
 
struct  PositionedWithId_ScenarioEvent
 
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  SearchReplaceWidget
 
class  SearchWidget
 
struct  SelectedNodes
 
class  SelectionStackWidget
 
class  SelectionState
 
class  SeparatorItem
 
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
 
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  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

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)
 
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)
 
QPointF newProcessPosition (const IntervalModel &cst) 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)
 
void createProcessInCable (Scenario::ScenarioDocumentPresenter &parent, const Library::ProcessData &dat, const Process::Cable &cbl)
 
void loadPresetInCable (Scenario::ScenarioDocumentPresenter &parent, const Process::Preset &dat, const Process::Cable &cbl)
 
void createProcessBeforePort (Scenario::ScenarioDocumentPresenter &parent, const Library::ProcessData &dat, const Process::ProcessModel &parentProcess, const Process::Inlet &p)
 
void createProcessAfterPort (Scenario::ScenarioDocumentPresenter &parent, const Library::ProcessData &dat, const Process::ProcessModel &parentProcess, const Process::Outlet &p)
 
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)
 
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)
 
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

const double deltaX = 10.
 
const double deltaY = 45.
 

Function Documentation

◆ 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