vexflow

import { Element } from './element'; import { Fraction } from './fraction'; import { RenderContext } from './rendercontext'; import { StemmableNote } from './stemmablenote'; import { Voice } from './voice'; export declare const BEAM_LEFT = "L"; export declare const BEAM_RIGHT = "R"; export declare const BEAM_BOTH = "B"; export type PartialBeamDirection = typeof BEAM_LEFT | typeof BEAM_RIGHT | typeof BEAM_BOTH; /** `Beams` span over a set of `StemmableNotes`. */ export declare class Beam extends Element { static get CATEGORY(): string; render_options: { flat_beam_offset?: number; flat_beams: boolean; secondary_break_ticks?: number; show_stemlets: boolean; beam_width: number; max_slope: number; min_slope: number; slope_iterations: number; slope_cost: number; stemlet_extension: number; partial_beam_length: number; min_flat_beam_offset: number; }; notes: StemmableNote[]; postFormatted: boolean; slope: number; private readonly stem_direction; private readonly ticks; private y_shift; private break_on_indices; private beam_count; private unbeamable?; /** * Overrides to default beam directions for secondary-level beams that do not * connect to any other note. See further explanation at * `setPartialBeamSideAt` */ private forcedPartialDirections; /** Get the direction of the beam */ getStemDirection(): number; /** * Get the default beam groups for a provided time signature. * Attempt to guess if the time signature is not found in table. * Currently this is fairly naive. */ static getDefaultBeamGroups(time_sig: string): Fraction[]; /** * A helper function to automatically build basic beams for a voice. For more * complex auto-beaming use `Beam.generateBeams()`. * @param voice the voice to generate the beams for * @param stem_direction a stem direction to apply to the entire voice * @param groups an array of `Fraction` representing beat groupings for the beam */ static applyAndGetBeams(voice: Voice, stem_direction?: number, groups?: Fraction[]): Beam[]; /** * A helper function to autimatically build beams for a voice with * configuration options. * * Example configuration object: * * ``` * config = { * groups: [new Vex.Flow.Fraction(2, 8)], * stem_direction: -1, * beam_rests: true, * beam_middle_only: true, * show_stemlets: false * }; * ``` * @param notes an array of notes to create the beams for * @param config the configuration object * @param config.stem_direction set to apply the same direction to all notes * @param config.beam_rests set to `true` to include rests in the beams * @param config.beam_middle_only set to `true` to only beam rests in the middle of the beat * @param config.show_stemlets set to `true` to draw stemlets for rests * @param config.maintain_stem_directions set to `true` to not apply new stem directions * @param config.groups array of `Fractions` that represent the beat structure to beam the notes * */ static generateBeams(notes: StemmableNote[], config?: { flat_beam_offset?: number; flat_beams?: boolean; secondary_breaks?: string; show_stemlets?: boolean; maintain_stem_directions?: boolean; beam_middle_only?: boolean; beam_rests?: boolean; groups?: Fraction[]; stem_direction?: number; }): Beam[]; constructor(notes: StemmableNote[], auto_stem?: boolean); /** Get the notes in this beam. */ getNotes(): StemmableNote[]; /** Get the max number of beams in the set of notes. */ getBeamCount(): number; /** Set which note `indices` to break the secondary beam at. */ breakSecondaryAt(indices: number[]): this; /** * Forces the direction of a partial beam (a secondary-level beam that exists * on one note only of the beam group). This is useful in rhythms such as 6/8 * eighth-sixteenth-eighth-sixteenth, where the direction of the beam on the * first sixteenth note can help imply whether the rhythm is to be felt as * three groups of eighth notes (typical) or as two groups of three-sixteenths * (less common): * ``` * ┌───┬──┬──┐ ┌──┬──┬──┐ * │ ├─ │ ─┤ vs │ ─┤ │ ─┤ * │ │ │ │ │ │ │ │ * ``` */ setPartialBeamSideAt(noteIndex: number, side: PartialBeamDirection): this; /** * Restore the default direction of a partial beam (a secondary-level beam * that does not connect to any other notes). */ unsetPartialBeamSideAt(noteIndex: number): this; /** Return the y coordinate for linear function. */ getSlopeY(x: number, first_x_px: number, first_y_px: number, slope: number): number; /** Calculate the best possible slope for the provided notes. */ calculateSlope(): void; /** Calculate a slope and y-shift for flat beams. */ calculateFlatSlope(): void; /** Return the Beam y offset. */ getBeamYToDraw(): number; /** * Create new stems for the notes in the beam, so that each stem * extends into the beams. */ applyStemExtensions(): void; /** Return upper level beam direction. */ lookupBeamDirection(duration: string, prev_tick: number, tick: number, next_tick: number, noteIndex: number): PartialBeamDirection; /** Get the x coordinates for the beam lines of specific `duration`. */ getBeamLines(duration: string): { start: number; end?: number; }[]; /** Render the stems for each note. */ protected drawStems(ctx: RenderContext): void; protected drawBeamLines(ctx: RenderContext): void; /** Pre-format the beam. */ preFormat(): this; /** * Post-format the beam. This can only be called after * the notes in the beam have both `x` and `y` values. ie: they've * been formatted and have staves. */ postFormat(): void; /** Render the beam to the canvas context */ draw(): void; }