Set or unset the selection.

This is the Cmd level of Ui.set_selection and should be called by any Cmd that wants to set the selection.

The insert selnum always has an orientation, so if Sel.orientation is Sel.None, default to Cmd.state_note_orientation. Otherwise, update the note orientation, so the visible orientation and actual orientation stay in sync.

Set a selection in the current view.

For point selections, set a play position selection on the equivalent time in sub-blocks. This makes it easier to edit the super-block relative to the sub-block.

TODO if multiple calls overlap, I should draw multiple selections, but Ui.set_selection doesn't support that, even though the underlying BlockC.set_selection does.

Update the selection's orientation to match Cmd.state_note_orientation.

Collapse the selection to a point at its (cur_track, cur_pos).

Advance the insert selection by the current step, which is a popular thing to do.

How to move a selection.

Use this Move mode when you don't have a more specific idea.

Advance the given selection by the current step.

The selection will maintain its current track span, be set to a point, and advance to the next relevant mark. "next relevant mark" is the next visible mark in the ruler to the left.

Move the selection across tracks by shift, possibly skipping non-event tracks and collapsed tracks.

Unlike shift, this uses Sel.union, which means that the selection will always expand, instead of only expanding if the current track is moving away from the start track. This is because I use this as a way to expand the selection rather than move it.

Find the element before the predicate matches, or the last element if it never matches.

Get tracks either starting from the right of the selection, or the left. Unselectable tracks are omitted.

Progressive selection: select the rest of the track, then the entire track, then the whole block.

TrackNum 0, assumed to be a ruler, is omitted, since selecting the ruler is not only not useful, it tends to make cmds that want to get a TrackId abort.

Extend the selection horizontally to encompass all tracks. If it already does, reset the track selection to the previous one.

Select clicked on track.

Extend the selection to the end of then block. This sets Sel.start_pos, with the assumption that Sel.cur_pos is onscreen. This is so auto_scroll won't jump to the bottom of the block.

Set the selection based on a click or drag.

Like cmd_mouse_selection, but snap the selection to the current time step.

Like mouse_drag but specialized for drags on the track.

Get the clicked or dragged range, or abort if this isn't a drag Msg. This accepts clicks as well, and considers them an empty range.

Figure out how much to scroll to keep the selection visible and with reasonable space around it.

Anyone who wants to set a selection and automatically scroll the window to follow the selection should use this function.

If the selection has scrolled off the edge of the window, automatically scroll it so that the "current" end of the selection is in view.

Find the track scroll that would put the given selection into view.

(mouse_down, mouse_modifier, (mouse_track, mouse_pos))

Get the ruler that applies to the given track. Search left for the closest ruler that has all the given marklist names. This includes ruler tracks and the rulers of event tracks.

Get the "point" position of a Selection.

When multiple tracks are selected, only one can be the point. This is Sel.cur_track, and in fact must be, because Sel.start_track may be an invalid tracknum. That is so a selection can maintain its shape even if it momentarily goes out of bounds.

A point on a track.

Get the "insert position", which is the start track and position of the insert selection. Abort if it's not an event track.

Return the leftmost tracknum and trackpos, even if it's not an event track.

The most general insertion point function.

Given a block, get the selection on it, if any. If there are multiple views, take the one with the alphabetically first ViewId.

I'm not sure how to choose, but the first one seems reasonable for now.

Get the point track of a selection.

The selection is in the Ui.State, but focused view is in Cmd.State. Extracting it out lets me depend only on Ui.M, not Cmd.M. Also it decouples selection functions from the current Ui.State and Cmd.State.

Get the real time range of the focused selection. If there's a root block, then it will be in relative to that root, otherwise it's equivalent to local_realtime.

RealTime of the given ScoreTime, relative to the root block. This is the closest we get to an absolute real time.

This is like get_insert, except get the selection on the root block, falling back to the current one if there is none.

Get the current selection in RealTime relative to another block.

If a block is called in multiple places, a score time on it may occur at multiple real times. Pick the real time from the given selection which is closest to the real time of the selection on the given root block.

If there's no selection on the root block then return the RealTime from the block's first occurrance.

Get the RealTime range of the current selection, as derived from current selection's block. This means that the top should be 0.

This is like relative_realtime but gets a RealTime relative to a Point, not a range.

Selected events per track. Gives events before, within, and after the selection. As usual, previous events are in descending order.

All selected events. events_around is the default selection behaviour.

Like events, but only for the sel_point_track.

Get events exactly at the point. This gets both positive and negative events, so each track may have up to 2 events.

Get events in the selection, but if no events are selected, expand it to include a neighboring event, as documented in select_neighbor.

Normally the range is half-open by event orientation, so a positive event at the end of the selection won't be included. But there's a special hack where if the end of the selection happens to be the end of the block, a positive event there will be included anyway. Otherwise it's annoying to select a final event (unless it's negative).

This is the standard definition of a selection, and should be used in all standard selection using commands.

This is similar to events_around, except that the direction is reversed: it favors the next positive event, or the previous negative one. Also this assumes a point selection and only selects one event per track.

Per-track selection info.

The TrackNums are sorted, and the TrackIds are likewise in left-to-right order. Only TrackNums for event tracks are returned, so both lists should have the same length and correspond if you zip them up.

Get selected event tracks along with the selection. The tracks are returned in ascending order. Only event tracks are returned, and tracks merged into the selected tracks are included.

Just the TrackIds part of tracks.

Selected tracks, including merged tracks.

Selected tracks, not including merged tracks.

Keep only this many selection history entries. This is hardcoded and low since I'm probably not interested in ancient selections.