Score state. When you save a score, this is what is saved to disk.

Like empty, but the state is initialized with the current creation time.

Clear out data that shouldn't be saved.

Address a track in a block. This is similar to a TrackId, except it doesn't guarantee that the track is an event track.

A position on a track that can be indicated on the UI. Its Pretty instance emits a string, which if logged or copy-pasted into the REPL, will cause that section of score to be highlighted.

Summary information on a Track.

Monads implementing this class can call the UI state functions directly.

Just a convenient abbreviation.

This directly modifies the state, and can break internal invariants. put is slower but safer since it checks those invariants.

Run the given StateT with the given initial state, and return a new state along with updates. Normally updates are produced by diff, but for efficiency updates to track data are accumulated when they are actually made. All the UI needs is a TrackTime range to redraw in, and redrawing the whole track isn't that expensive.

See the StateStack comment for more.

A form of run that returns only the val and automatically runs in Identity.

As with unsafe_put, this directly modifies the state. modify is the safe version.

TODO verify

This updates all tracks because I don't know what you modified in there.

An arbitrary modify. It's unsafe because it doesn't check internal invariants, and inefficient because it damages all tracks. Use more specific modify_* functions, if possible.

Emit track updates for all tracks. Use this when events have changed but I don't know which ones, e.g. when loading a file or restoring a previous state.

Abort is used by Cmd, so don't throw it from here. This isn't exactly modular, but ErrorT can't be composed and extensible exceptions are too much bother at the moment.

Unlike other State fields, you can modify Config freely without worrying about breaking invariants. TODO except allocations have invariants.

Run the action with a modified state, and restore it.

TODO use this for read only. If used for write it bypasses UiConfig.allocate.

All ViewIds, in sorted order.

Create a new view. Block.view_tracks can be left empty, since it will be replaced by views generated from the the block. If the caller uses the Block.view constructor, it won't have to worry about this.

Throw if the ViewId already exists.

Set a status variable on a view.

Only ui_update is supposed to call this, because the UI is responsible for the padding.

Get view_id's selection at selnum, or Nothing if there is none.

Replace any selection on view_id at selnum with sel.

Shift the selection, clipping if it's out of range. While the sel_cur_track won't be on a non-selectable track after this, the selection may still include one.

Shift a tracknum to another track, skipping unselectable tracks.

Get the tracknums from a block that should be selectable.

Get all blocks along with their tracks.

Make a new block. If it's the first one, it will be set as the root. This is the low level version, you probably want to use create_block.

Throw if the BlockId already exists.

Make a new block with the default Block.Config.

Destroy the block and all the views that display it. If the block was the root, it will be be unset. The block's tracks are left intact.

Get all views of a given block.

Set or clear this block as an integrate destination. The automatic integration system will update it from the given source block.

Set or clear the block's manual integration Block.NoteDestinations. This just attaches (or removes) the integrate information to the block so a future integration can use it to merge, and then call this function again.

The play box doesn't use a char, so I leave that out.

Get the end of the block according to the ruler. This means that if the block has no rulers (e.g. a clipboard block) then block_ruler_end will be 0.

Get the end of the block according to the last event of the block.

Get the maximum of ruler end and event end. The end may still be 0 if the block is totally empty.

The logical range is defined by Ruler.bounds_of and is intended to correspond to the "note" that this block defines.

Toggle the given edge in the block's skeleton. If a cycle would be created, refuse to add the edge and return False. The edge is in (parent, child) order.

Add the edges to the skeleton. Throw if they would produce a cycle.

The first tracknum is spliced above the second.

The first tracknum is spliced below the second.

Insert a track at the given TrackNum. The TrackNum can be out of range to insert a track at the beginning or append it to the end.

This will throw if it's an event track and the block already contains that TrackId. This invariant ensures that a (BlockId, TrackNum) is interchangeable with a TrackId.

Remove the track at the given tracknum.

Move a track from one tracknum to another.

Number of tracks in the block. This includes the ruler, so subtract 1 if you want all non-ruler tracks.

Get the Track at tracknum, or Nothing if its out of range.

Like track_at, but only for event tracks.

Like event_track_at but throws if it's not there or not an event track.

Get the RulerId of an event or ruler track, or Nothing if the tracknum is out of range or doesn't have a ruler.

0 is the conventional ruler tracknum.

Get all TrackIds of the given block.

Get all TrackIds of the given block, along with their tracknums.

Get tracks along with their TrackNums.

There can only be one TrackId per block, which allows TrackNums and TrackIds to be interchangeable. This is enforced by insert_track.

The inverse is event_track_at.

Merge the from tracknum into the to tracknum and collapse from.

Reverse merge_track: remove the merged tracks and expand their occurrances in the given block. "Unmerge" is not a graceful term, but at least it's obviously the opposite of "merge".

Set rulers, one per track.

Replace one RulerId with another on the given block.

It's more convenient to do here than removing and inserting tracks, and easy since there's no "one per block" invariant to maintain with ruler ids.

Resolve a TracklikeId to a Tracklike.

Insert the given track with the given ID.

Throw if the TrackId already exists.

Destroy the track and remove it from all the blocks it's in. No-op if the TrackId doesn't exist.

Find track_id in all the blocks it exists in, and return the track info for each tracknum at which track_id lives. Blocks with no matching tracks won't be returned, so the return track lists will always be non-null.

Insert events into track_id as per Events.insert.

Like insert_events, but clip the events to the end of a block.

This is necessarily block specific, because block duration is defined by its ruler. Still, you should use this in preference to insert_events.

This uses block_end, which means that if events don't already go past the end of the ruler, they won't after this is called. If they are already past (e.g. there is no ruler), then they will only be clipped if they move to later in time. This might be confusing, but it seems generally convenient to not have to constantly manually trim events when they get moved past the end of the ruler, but definitely inconvenient for events to just disappear when there is no ruler.

Modify the events on a track, and assume the entire track has been damaged.

Just like modify_events, except that it expects you only modified a few events, and will only emit damage for the changed parts.

Remove a single event by start and orientation. TODO I think remove_events_range is now just as expressive and can be just as efficient

Just like mapM_ (remove_event track_id) but more efficient. TODO at least I hope, it got sort of complicated.

Get the end of the last event of the block.

Insert the given ruler with the given ID.

Throw if the RulerId already exists.

Destroy the ruler and remove it from all the blocks it's in.

Just like blocks_with_track_id except for ruler_id.

Since all TracklikeIds must have a ruler, all States have a special empty ruler that can be used in a "no ruler" situation.

This RulerId is implicitly present in every block. It's not actually in state_rulers to avoid it getting renamed or deleted, but get_ruler will pretend it exists. As long as everyone that cares about no_ruler (which is only verify and get_tracklike for Ui.Sync) uses get_ruler then they won't be confused by tracks that have no_ruler.

This is like verify, but less complete. It returns Left if it wants you to reject the new state entirely.

verify is better, but more expensive, so I'm reluctant to run it on every single cmd. If I run verify before unsafe puts and trust this module to maintain invariants then I don't need to, but I don't fully trust this module.

TODO a better approach would be to make sure Sync can't be broken by State.

Unfortunately there are some invariants to protect within State. They can all be fixed by dropping things, so this will fix them and return a list of warnings.

Read an ID of the form "namespace/name", or just "name", filling in the current namespace if it's not present.