alphaTab.AlphaTabApiBase

This class represents the public API of alphaTab and provides all logic to display a music sheet in any UI using the given IUiFacade

 class AlphaTabApiBase<TSettings>

Properties

actualPlayerMode

The actual player mode which is currently active. Allows determining whether a backing track or the synthesizer is active in case automatic detection is enabled.

JavaScript

readonly actualPlayerMode: PlayerMode;

C#

PlayerMode ActualPlayerMode { get; }

Kotlin

val actualPlayerMode: PlayerMode

boundsLookup

The tick cache allowing lookup of midi ticks to beats. In older versions of alphaTab you can access the boundsLookup via boundsLookup on renderer .

After the rendering completed alphaTab exposes via this lookup the location of the individual notation elements. The lookup provides fast access to the bars and beats at a given location. If the CoreSettings.includeNoteBounds option was activated also the location of the individual notes can be obtained.

The property contains a BoundsLookup instance which follows a hierarchical structure that represents the tree of rendered elements.

The hierarchy is: staffSystems > bars(1) > bars(2) > beats > notes

• staffSystems - Represent the bounds of the individual systems ("rows") where staves are contained.
• bars(1) - Represent the bounds of all bars for a particular master bar across all tracks.
• bars(2) - Represent the bounds of an individual bar of a track. The bounds on y-axis span the region of the staff and notes might exceed this bounds.
• beats - Represent the bounds of the individual beats within a track. The bounds on y-axis are equal to the bar bounds.
• notes - Represent the bounds of the individual note heads/numbers within a track.

Each bounds hierarchy have a visualBounds and realBounds.

• visualBounds - Represent the area covering all visually visible elements
• realBounds - Represents the actual bounds of the elements in this beat including whitespace areas.
• noteHeadBounds (only on notes level) - Represents the area of the note heads or number based on the staff

You can check out the individual sizes and regions.

JavaScript

readonly boundsLookup: BoundsLookup | null;

C#

BoundsLookup? BoundsLookup { get; }

Kotlin

val boundsLookup: BoundsLookup?

canvasElement

The UI container that will hold all rendered results.

JavaScript

readonly canvasElement: IContainer;

C#

IContainer CanvasElement { get; }

Kotlin

val canvasElement: IContainer

container

The UI container that holds the whole alphaTab control. Gets the UI container that represents the element on which alphaTab was initialized. Note that this is not the raw instance, but a UI framework specific wrapper for alphaTab.

JavaScript

readonly container: IContainer;

C#

IContainer Container { get; }

Kotlin

val container: IContainer

countInVolume

The volume of the count-in metronome ticks. Gets or sets the volume of the metronome during the count-in of the song. By default the count-in is disabled but can be enabled by setting the volume different.

JavaScript

countInVolume: number = 0;

C#

double CountInVolume { get; set; } = 0

Kotlin

var countInVolume: Double = 0

customScrollHandler

A custom scroll handler which will be used to handle scrolling operations during playback.

JavaScript

customScrollHandler?: IScrollHandler;

C#

IScrollHandler CustomScrollHandler { get; set; }

Kotlin

var customScrollHandler: IScrollHandler

endTick

The total length of the song in midi ticks.

JavaScript

readonly endTick: number;

C#

double EndTick { get; }

Kotlin

val endTick: Double

endTime

The total length of the song in milliseconds.

JavaScript

readonly endTime: number;

C#

double EndTime { get; }

Kotlin

val endTime: Double

isLooping

Whether the playback should automatically restart after it finished. This setting controls whether the playback should automatically restart after it finished to create a playback loop.

JavaScript

isLooping: boolean = false;

C#

bool IsLooping { get; set; } = false

Kotlin

var isLooping: Boolean = false

isReadyForPlayback

Whether the player is ready for starting the playback. Gets whether the synthesizer is ready for playback. The player is ready for playback when all background workers are started, the audio output is initialized, a soundfont is loaded, and a song was loaded into the player as midi file.

JavaScript

readonly isReadyForPlayback: boolean;

C#

bool IsReadyForPlayback { get; }

Kotlin

val isReadyForPlayback: Boolean

masterVolume

The current master volume as percentage (0-1). Gets or sets the master volume of the overall audio being played. The volume is annotated in percentage where 1.0 would be the normal volume and 0.5 only 50%.

JavaScript

masterVolume: number;

C#

double MasterVolume { get; set; }

Kotlin

var masterVolume: Double

metronomeVolume

The metronome volume as percentage (0-1). Gets or sets the volume of the metronome. By default the metronome is disabled but can be enabled by setting the volume different.

JavaScript

metronomeVolume: number = 0;

C#

double MetronomeVolume { get; set; } = 0

Kotlin

var metronomeVolume: Double = 0

midiEventsPlayedFilter

The midi events which will trigger the midiEventsPlayed event Gets or sets the midi events which will trigger the midiEventsPlayed event. With this filter set you can enable that alphaTab will signal any midi events as they are played by the synthesizer. This allows reacing on various low level audio playback elements like notes/rests played or metronome ticks.

Refer to the related guide to learn more about this feature.

JavaScript

midiEventsPlayedFilter: MidiEventType[] = [];

C#

IList<MidiEventType> MidiEventsPlayedFilter { get; set; } = []

Kotlin

var midiEventsPlayedFilter: alphaTab.collections.List<MidiEventType> = []

midiTickShift

An indicator by how many midi-ticks the song contents are shifted. Grace beats at start might require a shift for the first beat to start at 0. This information can be used to translate back the player time axis to the music notation.

JavaScript

readonly midiTickShift: number;

C#

double MidiTickShift { get; }

Kotlin

val midiTickShift: Double

playbackRange

The range of the song that should be played. Gets or sets the range of the song that should be played. The range is defined in midi ticks or the whole song is played if the range is set to null

JavaScript

playbackRange: PlaybackRange | null = null;

C#

PlaybackRange? PlaybackRange { get; set; } = null

Kotlin

var playbackRange: PlaybackRange? = null

playbackSpeed

The current playback speed as percentage Controls the current playback speed as percentual value. Normal speed is 1.0 (100%) and 0.5 would be 50%.

JavaScript

playbackSpeed: number = 1;

C#

double PlaybackSpeed { get; set; } = 1

Kotlin

var playbackSpeed: Double = 1

player

The alphaSynth player used for playback. This is the low-level API to the Midi synthesizer used for playback. Gets access to the underling IAlphaSynth that is used for the audio playback.

JavaScript

readonly player: IAlphaSynth | null;

C#

IAlphaSynth? Player { get; }

Kotlin

val player: IAlphaSynth?

playerState

The current player state. Gets the current player state, meaning whether it is paused or playing.

JavaScript

readonly playerState: PlayerState;

C#

PlayerState PlayerState { get; }

Kotlin

val playerState: PlayerState

renderer

The score renderer used for rendering the music sheet. This is the low-level API responsible for the actual rendering engine. Gets access to the underling IScoreRenderer that is used for the rendering.

JavaScript

readonly renderer: IScoreRenderer;

C#

IScoreRenderer Renderer { get; }

Kotlin

val renderer: IScoreRenderer

score

The score holding all information about the song being rendered

JavaScript

readonly score: Score | null;

C#

Score? Score { get; }

Kotlin

val score: Score?

settings

The settings that are used for rendering the music notation. Gets access to the underling Settings object that is currently used by alphaTab.

JavaScript

settings: Settings;

C#

Settings Settings { get; set; }

Kotlin

var settings: Settings

tickCache

The tick cache allowing lookup of midi ticks to beats. Gets the tick cache allowing lookup of midi ticks to beats. If the player is enabled, a midi file will be generated for the loaded Score for later playback. During this generation this tick cache is filled with the exact midi ticks when beats are played.

The findBeat method allows a lookup of the beat related to a given input midi tick.

JavaScript

readonly tickCache: MidiTickLookup | null;

C#

MidiTickLookup? TickCache { get; }

Kotlin

val tickCache: MidiTickLookup?

tickPosition

The position within the song in midi ticks.

JavaScript

tickPosition: number;

C#

double TickPosition { get; set; }

Kotlin

var tickPosition: Double

timePosition

The position within the song in milliseconds

JavaScript

timePosition: number;

C#

double TimePosition { get; set; }

Kotlin

var timePosition: Double

tracks

The list of the tracks that are currently rendered.

JavaScript

readonly tracks: Track[];

C#

IList<Track> Tracks { get; }

Kotlin

val tracks: alphaTab.collections.List<Track>

uiFacade

The UI facade used for interacting with the user interface (like the browser). The implementation depends on the platform alphaTab is running in (e.g. the web version in the browser, WPF in .net etc.)

JavaScript

readonly uiFacade: IUiFacade<TSettings>;

C#

IUiFacade<TSettings> UiFacade { get; }

Kotlin

val uiFacade: IUiFacade<TSettings>

Methods

applyPlaybackRangeFromHighlight

Applies the playback range from the currently highlighted range. This method can be used when building custom selection systems (e.g. having draggable handles).

JavaScript

applyPlaybackRangeFromHighlight(): void

C#

void ApplyPlaybackRangeFromHighlight()

Kotlin

fun applyPlaybackRangeFromHighlight(): Unit

changeTrackMute

Changes the given tracks to be muted or not. This will result in a muting of the primary and secondary midi channel that the track uses for playback. If the track shares the channels with another track, all tracks will be muted as during playback they cannot be distinguished.

JavaScript

changeTrackMute(tracks: Track[], mute: boolean): void

C#

void ChangeTrackMute(IList<Track> tracks, bool mute)

Kotlin

fun changeTrackMute(tracks: alphaTab.collections.List<Track>, mute: Boolean): Unit

Parameter	Summary
tracksAll	The list of track to mute or unmute.
muteAll	If set to true, the tracks will be muted. If false they are unmuted.

changeTrackSolo

Changes the given tracks to be played solo or not. If any track is set to solo, all other tracks are muted, unless they are also flagged as solo. This will result in a solo playback of the primary and secondary midi channel that the track uses for playback. If the track shares the channels with another track, all related tracks will be played as they cannot be distinguished.

JavaScript

changeTrackSolo(tracks: Track[], solo: boolean): void

C#

void ChangeTrackSolo(IList<Track> tracks, bool solo)

Kotlin

fun changeTrackSolo(tracks: alphaTab.collections.List<Track>, solo: Boolean): Unit

Parameter	Summary
tracksAll	The list of tracks to play solo or not.
soloAll	If set to true, the tracks will be added to the solo list. If false, they are removed.

changeTrackTranspositionPitch

Changes the pitch transpose applied to the given tracks. These pitches are additional to the ones applied to the song via the settings and data model and allows a more live-update via a UI.

JavaScript

changeTrackTranspositionPitch(tracks: Track[], semitones: number): void

C#

void ChangeTrackTranspositionPitch(IList<Track> tracks, double semitones)

Kotlin

fun changeTrackTranspositionPitch(tracks: alphaTab.collections.List<Track>, semitones: Double): Unit

Parameter	Summary
tracksAll	The list of tracks to change.
semitonesAll	The number of semitones to apply as pitch offset.

changeTrackVolume

Changes the volume of the given tracks. This will result in a volume change of the primary and secondary midi channel that the track uses for playback. If the track shares the channels with another track, all related tracks will be changed as they cannot be distinguished.

JavaScript

changeTrackVolume(tracks: Track[], volume: number): void

C#

void ChangeTrackVolume(IList<Track> tracks, double volume)

Kotlin

fun changeTrackVolume(tracks: alphaTab.collections.List<Track>, volume: Double): Unit

Parameter	Summary
tracksAll	The tracks for which the volume should be changed.
volumeAll	The volume to set for all tracks in percent (0-1)

clearPlaybackRangeHighlight

Clears the highlight markers marking the currently selected playback range. Unlike actually setting playbackRange this method only clears the selection markers without actually changing the playback range. This method can be used when building custom selection systems (e.g. having draggable handles).

JavaScript

clearPlaybackRangeHighlight(): void

C#

void ClearPlaybackRangeHighlight()

Kotlin

fun clearPlaybackRangeHighlight(): Unit

destroy

Destroys the alphaTab control and restores the initial state of the UI. This function destroys the alphaTab control and tries to restore the initial state of the UI. This might be useful if our website is quite dynamic and you need to uninitialize alphaTab from an element again. After destroying alphaTab it cannot be used anymore. Any further usage leads to unexpected behavior.

JavaScript

destroy(): void

C#

void Destroy()

Kotlin

fun destroy(): Unit

enumerateOutputDevices

Loads and lists the available output devices which can be used by the player. Will request permissions if needed.

The values provided, can be passed into setOutputDevice to change dynamically the output device on which the sound is played.

In the web version this functionality relies on experimental APIs and might not yet be available in all browsers. https://caniuse.com/mdn-api_audiocontext_sinkid

JavaScript

enumerateOutputDevices(): Promise<ISynthOutputDevice[]>

C#

System.Threading.Task<IList<ISynthOutputDevice>> EnumerateOutputDevices()

Kotlin

suspend fun enumerateOutputDevices(): alphaTab.collections.List<ISynthOutputDevice>

Returns

the list of available devices or an empty list if there are no permissions, or the player is not enabled.

exportAudio

Starts the audio export for the currently loaded song. This will not export or use any backing track media but will always use the synthesizer to generate the output. This method works with any PlayerMode active but changing the mode during export can lead to unexpected side effects.

See Audio Export for further guidance how to use this feature.

JavaScript

exportAudio(options: AudioExportOptions): Promise<IAudioExporter>

C#

System.Threading.Task<IAudioExporter> ExportAudio(AudioExportOptions options)

Kotlin

suspend fun exportAudio(options: AudioExportOptions): IAudioExporter

Parameter	Summary
optionsAll	The export options.

Returns

An exporter instance to export the audio in a streaming fashion.

getOutputDevice

The currently configured output device if changed via setOutputDevice . Assumes setOutputDevice has been used. In the web version this functionality relies on experimental APIs and might not yet be available in all browsers. https://caniuse.com/mdn-api_audiocontext_sinkid

JavaScript

getOutputDevice(): Promise<ISynthOutputDevice | null>

C#

System.Threading.Task<ISynthOutputDevice?> GetOutputDevice()

Kotlin

suspend fun getOutputDevice(): ISynthOutputDevice?

Returns

The custom configured output device which was set via setOutputDevice or null if the default outputDevice is used. The output device might change dynamically if devices are connected/disconnected (e.g. bluetooth headset).

highlightPlaybackRange

Places the highlight markers at the specified start and end-beat range. Unlike actually setting playbackRange this method only places the selection markers without actually changing the playback range. This method can be used when building custom selection systems (e.g. having draggable handles).

JavaScript

highlightPlaybackRange(startBeat: Beat, endBeat: Beat): void

C#

void HighlightPlaybackRange(Beat startBeat, Beat endBeat)

Kotlin

fun highlightPlaybackRange(startBeat: Beat, endBeat: Beat): Unit

Parameter	Summary
startBeatAll	The start beat where the selection should start
endBeatAll	The end beat where the selection should end.

load

Initiates a load of the score using the given data.

JavaScript

load(scoreData: unknown, trackIndexes?: number[]): boolean

C#

bool Load(object scoreData, IList<double>? trackIndexes)

Kotlin

fun load(scoreData: Any, trackIndexes: alphaTab.collections.DoubleList?): Boolean

Parameter	Summary
scoreDataAll	The data container supported by IUiFacade . The supported types is depending on the platform: A alphaTab.model.Score instance (all platforms) A ArrayBuffer or Uint8Array containing one of the supported file formats (all platforms, native byte array or input streams on other platforms) A url from where to download the binary data of one of the supported file formats (browser only)
trackIndexesAll	The indexes of the tracks from the song that should be rendered. If not provided, the first track of the song will be shown.

Returns

true if the data object is supported and a load was initiated, otherwise false

loadMidiForScore

Re-creates the midi for the current score and loads it. This will result in the player to stop playback. Some setting changes require re-genration of the midi song.

JavaScript

loadMidiForScore(): void

C#

void LoadMidiForScore()

Kotlin

fun loadMidiForScore(): Unit

loadSoundFont

Triggers a load of the soundfont from the given data. AlphaTab only supports SoundFont2 and SoundFont3 since 1.4.0 encoded soundfonts for loading. To load a soundfont the player must be enabled in advance.

JavaScript

loadSoundFont(data: unknown, append?: boolean): boolean

C#

bool LoadSoundFont(object data, bool? append)

Kotlin

fun loadSoundFont(data: Any, append: Boolean?): Boolean

Parameter	Summary
dataAll	The data object to decode. The supported data types is depending on the platform. A ArrayBuffer or Uint8Array (all platforms, native byte array or input streams on other platforms) A url from where to download the binary data of one of the supported file formats (browser only)
appendAll	Whether to fully replace or append the data from the given soundfont.

Returns

true if the passed in object is a supported format and loading was initiated, otherwise false.

pause

Pauses the playback of the current song.

JavaScript

pause(): void

C#

void Pause()

Kotlin

fun pause(): Unit

play

Starts the playback of the current song.

JavaScript

play(): boolean

C#

bool Play()

Kotlin

fun play(): Boolean

Returns

true if the playback was started, otherwise false. Reasons for not starting can be that the player is not ready or already playing.

playBeat

Triggers the play of the given beat. This will stop the any other current ongoing playback. This method can be used in applications when individual beats need to be played for lesson or editor style purposes. The player will not report any change in state or playback position during the playback of the requested beat. It is a playback of audio separate to the main song playback.

JavaScript

playBeat(beat: Beat): void

C#

void PlayBeat(Beat beat)

Kotlin

fun playBeat(beat: Beat): Unit

Parameter	Summary
beatAll	the single beat to play

Returns

true if the playback was started, otherwise false. Reasons for not starting can be that the player is not ready or already playing.

playNote

Triggers the play of the given note. This will stop the any other current ongoing playback. This method can be used in applications when individual notes need to be played for lesson or editor style purposes. The player will not report any change in state or playback position during the playback of the requested note. It is a playback of audio separate to the main song playback.

JavaScript

playNote(note: Note): void

C#

void PlayNote(Note note)

Kotlin

fun playNote(note: Note): Unit

Parameter	Summary
noteAll	the single note to play

playPause

Toggles between play/pause depending on the current player state. If the player was playing, it will pause. If it is paused, it will initiate a play.

JavaScript

playPause(): void

C#

void PlayPause()

Kotlin

fun playPause(): Unit

render

Initiates a re-rendering of the current setup. If rendering is not yet possible, it will be deferred until the UI changes to be ready for rendering.

JavaScript

render(renderHints?: RenderHints): void

C#

void Render(RenderHints? renderHints)

Kotlin

fun render(renderHints: RenderHints?): Unit

Parameter	Summary
renderHintsAll	Additional hints to respect during layouting and rendering.

renderScore

Initiates a rendering of the given score.

JavaScript

renderScore(score: Score, trackIndexes?: number[], renderHints?: RenderHints): void

C#

void RenderScore(Score score, IList<double>? trackIndexes, RenderHints? renderHints)

Kotlin

fun renderScore(score: Score, trackIndexes: alphaTab.collections.DoubleList?, renderHints: RenderHints?): Unit

Parameter	Summary
scoreAll	The score containing the tracks to be rendered.
trackIndexesAll	The indexes of the tracks from the song that should be rendered. If not provided, the first track of the song will be shown.
renderHintsAll	Additional hints to respect during layouting and rendering.

renderTracks

Renders the given list of tracks.

JavaScript

renderTracks(tracks: Track[], renderHints?: RenderHints): void

C#

void RenderTracks(IList<Track> tracks, RenderHints? renderHints)

Kotlin

fun renderTracks(tracks: alphaTab.collections.List<Track>, renderHints: RenderHints?): Unit

Parameter	Summary
tracksAll	The tracks to render. They must all belong to the same score.
renderHintsAll	Additional hints to respect during layouting and rendering.

resetSoundFonts

Unloads all presets from previously loaded SoundFonts. This function resets the player internally to not have any SoundFont loaded anymore. This allows you to reduce the memory usage of the page if multiple partial SoundFonts are loaded via loadSoundFont(..., true). Depending on the workflow you might also just want to use loadSoundFont(..., false) once instead of unloading the previous SoundFonts.

JavaScript

resetSoundFonts(): void

C#

void ResetSoundFonts()

Kotlin

fun resetSoundFonts(): Unit

scrollToCursor

Initiates a scroll to the cursor.

JavaScript

scrollToCursor(): void

C#

void ScrollToCursor()

Kotlin

fun scrollToCursor(): Unit

setOutputDevice

Changes the output device which should be used for playing the audio (player must be enabled). Use enumerateOutputDevices to load the list of available devices.

In the web version this functionality relies on experimental APIs and might not yet be available in all browsers. https://caniuse.com/mdn-api_audiocontext_sinkid

JavaScript

setOutputDevice(device: ISynthOutputDevice | null): Promise<void>

C#

System.Threading.Task<void> SetOutputDevice(ISynthOutputDevice? device)

Kotlin

suspend fun setOutputDevice(device: ISynthOutputDevice?): Unit

Parameter	Summary
deviceAll	The output device to use, or null to switch to the default device.

stop

Stops the playback of the current song, and moves the playback position back to the start. If a dedicated playback range is selected, it will move the playback position to the start of this range, not the whole song.

JavaScript

stop(): void

C#

void Stop()

Kotlin

fun stop(): Unit

tex

Tells alphaTab to render the given alphaTex.

JavaScript

tex(tex: string, tracks?: number[]): void

C#

void Tex(string tex, IList<double>? tracks)

Kotlin

fun tex(tex: String, tracks: alphaTab.collections.DoubleList?): Unit

Parameter	Summary
texAll	The alphaTex code to render.
tracksAll	If set, the given tracks will be rendered, otherwise the first track only will be rendered.

updateSettings

Applies any changes that were done to the settings object. It also informs the renderer about any new values to consider. By default alphaTab will not trigger any re-rendering or settings update just if the settings object itself was changed. This method must be called to trigger an update of the settings in all components. Then a re-rendering can be initiated using the render method.

JavaScript

updateSettings(): void

C#

void UpdateSettings()

Kotlin

fun updateSettings(): Unit

updateSyncPoints

Triggers an update of the sync points for the current score after modification within the data model

JavaScript

updateSyncPoints(): void

C#

void UpdateSyncPoints()

Kotlin

fun updateSyncPoints(): Unit

Events

activeBeatsChanged

This event is fired when the currently active beats across all tracks change. Unlike the playedBeatChanged event this event contains the beats of all tracks and voices independent of them being rendered.

This event is fired when the currently active beats across all tracks change. Unlike the playedBeatChanged event this event contains the beats of all tracks and voices independent of them being rendered.

JavaScript

readonly activeBeatsChanged: IEventEmitterOfT<ActiveBeatsChangedEventArgs>;

C#

IEventEmitterOfT<ActiveBeatsChangedEventArgs> ActiveBeatsChanged { get; }

Kotlin

val activeBeatsChanged: IEventEmitterOfT<ActiveBeatsChangedEventArgs>

beatMouseDown

This event is fired whenever a the user presses the mouse button on a beat.

This event is fired whenever a the user presses the mouse button on a beat.

JavaScript

readonly beatMouseDown: IEventEmitterOfT<Beat>;

C#

IEventEmitterOfT<Beat> BeatMouseDown { get; }

Kotlin

val beatMouseDown: IEventEmitterOfT<Beat>

beatMouseMove

This event is fired whenever the user moves the mouse over a beat after the user already pressed the button on a beat.

This event is fired whenever the user moves the mouse over a beat after the user already pressed the button on a beat.

JavaScript

readonly beatMouseMove: IEventEmitterOfT<Beat>;

C#

IEventEmitterOfT<Beat> BeatMouseMove { get; }

Kotlin

val beatMouseMove: IEventEmitterOfT<Beat>

beatMouseUp

This event is fired whenever the user releases the mouse after a mouse press on a beat. This event is fired regardless of whether the mouse was released on a beat. The parameter is null if the mouse was released somewhere beside the beat.

This event is fired whenever the user releases the mouse after a mouse press on a beat. This event is fired regardless of whether the mouse was released on a beat. The parameter is null if the mouse was released somewhere beside the beat.

JavaScript

readonly beatMouseUp: IEventEmitterOfT<Beat | null>;

C#

IEventEmitterOfT<Beat?> BeatMouseUp { get; }

Kotlin

val beatMouseUp: IEventEmitterOfT<Beat?>

error

This event is fired when an error within alphatab occurred. This event is fired when an error within alphatab occurred. Use this event as global error handler to show errors to end-users. Due to the asynchronous nature of alphaTab, no call to the API will directly throw an error if it fails. Instead a signal to this error handlers will be sent.

This event is fired when an error within alphatab occurred. This event is fired when an error within alphatab occurred. Use this event as global error handler to show errors to end-users. Due to the asynchronous nature of alphaTab, no call to the API will directly throw an error if it fails. Instead a signal to this error handlers will be sent.

JavaScript

readonly error: IEventEmitterOfT<Error>;

C#

IEventEmitterOfT<System.Exception> Error { get; }

Kotlin

val error: IEventEmitterOfT<kotlin.Throwable>

midiEventsPlayed

This event is fired when the synthesizer played certain midi events. This event is fired when the synthesizer played certain midi events. This allows reacing on various low level audio playback elements like notes/rests played or metronome ticks.

Refer to the related guide to learn more about this feature.

Also note that the provided data models changed significantly in {@version 1.3.0}. We try to provide backwards compatibility until some extend but highly encourage changing to the new models in case of problems.

This event is fired when the synthesizer played certain midi events. This event is fired when the synthesizer played certain midi events. This allows reacing on various low level audio playback elements like notes/rests played or metronome ticks.

Refer to the related guide to learn more about this feature.

Also note that the provided data models changed significantly in {@version 1.3.0}. We try to provide backwards compatibility until some extend but highly encourage changing to the new models in case of problems.

JavaScript

readonly midiEventsPlayed: IEventEmitterOfT<MidiEventsPlayedEventArgs>;

C#

IEventEmitterOfT<MidiEventsPlayedEventArgs> MidiEventsPlayed { get; }

Kotlin

val midiEventsPlayed: IEventEmitterOfT<MidiEventsPlayedEventArgs>

midiLoad

This event is fired when a Midi file is being loaded. This event is fired when a Midi file for the song was generated and is being loaded by the synthesizer. This event can be used to inspect or modify the midi events which will be played for the song. This can be used to generate other visual representations of the song.

note

The generated midi file will NOT contain any metronome and count-in related events. The metronome and count-in ticks are handled within the synthesizer.

This event is fired when a Midi file is being loaded. This event is fired when a Midi file for the song was generated and is being loaded by the synthesizer. This event can be used to inspect or modify the midi events which will be played for the song. This can be used to generate other visual representations of the song.

note

The generated midi file will NOT contain any metronome and count-in related events. The metronome and count-in ticks are handled within the synthesizer.

JavaScript

readonly midiLoad: IEventEmitterOfT<MidiFile>;

C#

IEventEmitterOfT<MidiFile> MidiLoad { get; }

Kotlin

val midiLoad: IEventEmitterOfT<MidiFile>

midiLoaded

This event is fired when the Midi file needed for playback was loaded.

This event is fired when the Midi file needed for playback was loaded.

JavaScript

readonly midiLoaded: IEventEmitterOfT<PositionChangedEventArgs>;

C#

IEventEmitterOfT<PositionChangedEventArgs> MidiLoaded { get; }

Kotlin

val midiLoaded: IEventEmitterOfT<PositionChangedEventArgs>

noteMouseDown

This event is fired whenever a the user presses the mouse button on a note head/number. This event is fired whenever a the user presses the mouse button on a note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in boundsLookup .

This event is fired whenever a the user presses the mouse button on a note head/number. This event is fired whenever a the user presses the mouse button on a note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in boundsLookup .

JavaScript

readonly noteMouseDown: IEventEmitterOfT<Note>;

C#

IEventEmitterOfT<Note> NoteMouseDown { get; }

Kotlin

val noteMouseDown: IEventEmitterOfT<Note>

noteMouseMove

This event is fired whenever the user moves the mouse over a note after the user already pressed the button on a note. This event is fired whenever the user moves the mouse over a note after the user already pressed the button on a note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in boundsLookup

This event is fired whenever the user moves the mouse over a note after the user already pressed the button on a note. This event is fired whenever the user moves the mouse over a note after the user already pressed the button on a note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in boundsLookup

JavaScript

readonly noteMouseMove: IEventEmitterOfT<Note>;

C#

IEventEmitterOfT<Note> NoteMouseMove { get; }

Kotlin

val noteMouseMove: IEventEmitterOfT<Note>

noteMouseUp

This event is fired whenever the user releases the mouse after a mouse press on a note. This event is fired whenever a the user presses the mouse button on a note. This event is fired regardless of whether the mouse was released on a note. The parameter is null if the mouse was released somewhere beside the note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in the boundsLookup .

This event is fired whenever the user releases the mouse after a mouse press on a note. This event is fired whenever a the user presses the mouse button on a note. This event is fired regardless of whether the mouse was released on a note. The parameter is null if the mouse was released somewhere beside the note. It is only fired if CoreSettings.includeNoteBounds was set to true because only then this hit detection can be done. A click on a note is considered if the note head or the note number on tabs are clicked as documented in the boundsLookup .

JavaScript

readonly noteMouseUp: IEventEmitterOfT<Note | null>;

C#

IEventEmitterOfT<Note?> NoteMouseUp { get; }

Kotlin

val noteMouseUp: IEventEmitterOfT<Note?>

playbackRangeChanged

This event is fired when the playback range changed.

This event is fired when the playback range changed.

JavaScript

readonly playbackRangeChanged: IEventEmitterOfT<PlaybackRangeChangedEventArgs>;

C#

IEventEmitterOfT<PlaybackRangeChangedEventArgs> PlaybackRangeChanged { get; }

Kotlin

val playbackRangeChanged: IEventEmitterOfT<PlaybackRangeChangedEventArgs>

playbackRangeHighlightChanged

This event is fired the shown highlights for the selected playback range changes. This event is fired already during selection and not only when the selection is completed. This event can be used to place additional custom selection markers (like drag handles).

This event is fired the shown highlights for the selected playback range changes. This event is fired already during selection and not only when the selection is completed. This event can be used to place additional custom selection markers (like drag handles).

JavaScript

readonly playbackRangeHighlightChanged: IEventEmitterOfT<PlaybackHighlightChangeEventArgs>;

C#

IEventEmitterOfT<PlaybackHighlightChangeEventArgs> PlaybackRangeHighlightChanged { get; }

Kotlin

val playbackRangeHighlightChanged: IEventEmitterOfT<PlaybackHighlightChangeEventArgs>

playedBeatChanged

This event is fired when the played beat changed.

This event is fired when the played beat changed.

JavaScript

readonly playedBeatChanged: IEventEmitterOfT<Beat>;

C#

IEventEmitterOfT<Beat> PlayedBeatChanged { get; }

Kotlin

val playedBeatChanged: IEventEmitterOfT<Beat>

playerFinished

This event is fired when the playback of the whole song finished. This event is finished regardless on whether looping is enabled or not.

This event is fired when the playback of the whole song finished. This event is finished regardless on whether looping is enabled or not.

JavaScript

readonly playerFinished: IEventEmitter;

C#

IEventEmitter PlayerFinished { get; }

Kotlin

val playerFinished: IEventEmitter

playerPositionChanged

This event is fired when the current playback position of the song changed.

This event is fired when the current playback position of the song changed.

JavaScript

readonly playerPositionChanged: IEventEmitterOfT<PositionChangedEventArgs>;

C#

IEventEmitterOfT<PositionChangedEventArgs> PlayerPositionChanged { get; }

Kotlin

val playerPositionChanged: IEventEmitterOfT<PositionChangedEventArgs>

playerReady

This event is fired when all required data for playback is loaded and ready. This event is fired when all required data for playback is loaded and ready. The player is ready for playback when all background workers are started, the audio output is initialized, a soundfont is loaded, and a song was loaded into the player as midi file.

This event is fired when all required data for playback is loaded and ready. This event is fired when all required data for playback is loaded and ready. The player is ready for playback when all background workers are started, the audio output is initialized, a soundfont is loaded, and a song was loaded into the player as midi file.

JavaScript

readonly playerReady: IEventEmitter;

C#

IEventEmitter PlayerReady { get; }

Kotlin

val playerReady: IEventEmitter

playerStateChanged

This event is fired when the playback state changed.

This event is fired when the playback state changed.

JavaScript

readonly playerStateChanged: IEventEmitterOfT<PlayerStateChangedEventArgs>;

C#

IEventEmitterOfT<PlayerStateChangedEventArgs> PlayerStateChanged { get; }

Kotlin

val playerStateChanged: IEventEmitterOfT<PlayerStateChangedEventArgs>

postRenderFinished

This event is fired when the rendering of the whole music sheet is finished, and all handlers of renderFinished ran. If CoreSettings.enableLazyLoading is enabled not all partial images of the music sheet might be rendered. In this case the renderFinished event rather represents that the whole music sheet has been layouted and arranged and every partial image can be requested for rendering. If you neeed more fine-grained access to the actual layouting and rendering progress, you need to look at the low-level apis partialLayoutFinished and partialRenderFinished accessible via renderer .

This event is fired when the rendering of the whole music sheet is finished, and all handlers of renderFinished ran. If CoreSettings.enableLazyLoading is enabled not all partial images of the music sheet might be rendered. In this case the renderFinished event rather represents that the whole music sheet has been layouted and arranged and every partial image can be requested for rendering. If you neeed more fine-grained access to the actual layouting and rendering progress, you need to look at the low-level apis partialLayoutFinished and partialRenderFinished accessible via renderer .

JavaScript

readonly postRenderFinished: IEventEmitter;

C#

IEventEmitter PostRenderFinished { get; }

Kotlin

val postRenderFinished: IEventEmitter

renderFinished

This event is fired when the rendering of the whole music sheet is finished. This event is fired when the rendering of the whole music sheet is finished from the render engine side. There might be still tasks open for the display component to visually display the rendered components when this event is notified (e.g. resizing of DOM elements are done).

This event is fired when the rendering of the whole music sheet is finished. This event is fired when the rendering of the whole music sheet is finished from the render engine side. There might be still tasks open for the display component to visually display the rendered components when this event is notified (e.g. resizing of DOM elements are done).

JavaScript

readonly renderFinished: IEventEmitterOfT<RenderFinishedEventArgs>;

C#

IEventEmitterOfT<RenderFinishedEventArgs> RenderFinished { get; }

Kotlin

val renderFinished: IEventEmitterOfT<RenderFinishedEventArgs>

renderStarted

This event is fired when the rendering of the whole music sheet is starting. All preparations are completed and the layout and render sequence is about to start.

This event is fired when the rendering of the whole music sheet is starting. All preparations are completed and the layout and render sequence is about to start.

JavaScript

readonly renderStarted: IEventEmitterOfT<boolean>;

C#

IEventEmitterOfT<bool> RenderStarted { get; }

Kotlin

val renderStarted: IEventEmitterOfT<Boolean>

resize

This event is fired when alphaTab was resized and is about to rerender the music notation. This event is fired when alphaTab was resized and is about to rerender the music notation. Before the re-rendering on resize the settings will be updated in the related components. This means that any changes to the layout options or other display settings are considered. This allows to implement scenarios where maybe the scale or the layout mode dynamically changes along the resizing.

This event is fired when alphaTab was resized and is about to rerender the music notation. This event is fired when alphaTab was resized and is about to rerender the music notation. Before the re-rendering on resize the settings will be updated in the related components. This means that any changes to the layout options or other display settings are considered. This allows to implement scenarios where maybe the scale or the layout mode dynamically changes along the resizing.

JavaScript

readonly resize: IEventEmitterOfT<ResizeEventArgs>;

C#

IEventEmitterOfT<ResizeEventArgs> Resize { get; }

Kotlin

val resize: IEventEmitterOfT<ResizeEventArgs>

scoreLoaded

This event is fired whenever a new song is loaded. This event is fired whenever a new song is loaded or changing due to renderScore or renderTracks calls. It is fired after the transposition midi pitches from the settings were applied, but before any midi is generated or rendering is started. This allows any modification of the score before further processing.

This event is fired whenever a new song is loaded. This event is fired whenever a new song is loaded or changing due to renderScore or renderTracks calls. It is fired after the transposition midi pitches from the settings were applied, but before any midi is generated or rendering is started. This allows any modification of the score before further processing.

JavaScript

readonly scoreLoaded: IEventEmitterOfT<Score>;

C#

IEventEmitterOfT<Score> ScoreLoaded { get; }

Kotlin

val scoreLoaded: IEventEmitterOfT<Score>

settingsUpdated

This event is fired when a settings update was requested.

This event is fired when a settings update was requested.

JavaScript

readonly settingsUpdated: IEventEmitter;

C#

IEventEmitter SettingsUpdated { get; }

Kotlin

val settingsUpdated: IEventEmitter

soundFontLoaded

This event is fired when the SoundFont needed for playback was loaded.

This event is fired when the SoundFont needed for playback was loaded.

JavaScript

readonly soundFontLoaded: IEventEmitter;

C#

IEventEmitter SoundFontLoaded { get; }

Kotlin

val soundFontLoaded: IEventEmitter