smoosic
Version:
<sub>[Github site](https://github.com/Smoosic/smoosic) | [source documentation](https://smoosic.github.io/Smoosic/release/docs/modules.html) | [change notes](https://aarondavidnewman.github.io/Smoosic/changes.html) | [application](https://smoosic.github.i
226 lines • 8.24 kB
TypeScript
/**
* Classes to support a {@link SmoSystemStaff}, which is a container for measures and
* staff modifiers.
* @module /smo/data/systemStaff
* **/
import { SmoObjectParams, SmoAttrs } from './common';
import { SmoMeasure, SmoMeasureParamsSer } from './measure';
import { SmoRehearsalMarkParams, SmoTempoTextParams, SmoVolta } from './measureModifiers';
import { SmoInstrumentParams, StaffModifierBase, SmoInstrument, SmoInstrumentMeasure, SmoTie, SmoStaffTextBracket, SmoStaffTextBracketParamsSer, StaffModifierBaseSer, SmoTabStave } from './staffModifiers';
import { SmoPartInfo, SmoPartInfoParamsSer } from './partInfo';
import { SmoSelector } from '../xform/selections';
import { FontInfo } from '../../common/vex';
/**
* indicate that we need to serialize the key signature, etc.
* maps beause we are going to be deserializing again in a different score
* @category SmoObject
*/
export interface SmoStaffSerializationOptions {
skipMaps: boolean;
preserveIds: boolean;
}
/**
* Constructor parameters for {@link SmoSystemStaff}.
* Usually you will call
* {@link SmoSystemStaff.defaults}, and modify the parameters you need to change,
* or get the defaults from an existing staff
* @param renumberingMap For alternate number, pickups, etc.
* @param keySignatureMap map of keys to measures
* @param measureInstrumentMap map of instruments to staves
* @param measures array of {@link SmoMeasure}
* @param modifiers slurs and such
* @param partInfo
* @category SmoObject
*/
export interface SmoSystemStaffParams {
staffId: number;
/**
* For alternate number, pickups, etc.
* */
renumberingMap: Record<number, number>;
/**
* map of keys to measures
*/
keySignatureMap: Record<number, string>;
measureInstrumentMap: Record<number, SmoInstrumentParams>;
/**
* array of {@link SmoMeasure})
*/
measures: SmoMeasure[];
/**
* modifiers slurs and such
* */
modifiers: StaffModifierBase[];
/**
* information about the part
*/
partInfo?: SmoPartInfo;
/**
* text lines
*/
textBrackets?: SmoStaffTextBracket[];
/**
*guitar tablature
*/
tabStaves: SmoTabStave[];
}
/**
* Serialized components of a stave
* @category serialization
*/
export interface SmoSystemStaffParamsSer {
/**
* class name
*/
ctor: string;
/**
* index of the staff
*/
staffId: number;
/**
* map of measure numbers vs. indices of measures
*/
renumberingMap?: Record<number, number>;
/**
* locations of key signature changes
*/
keySignatureMap?: Record<number, string>;
/**
* map of measures to instruments (clef, transpose, sounds)
*/
measureInstrumentMap: Record<number, SmoInstrumentParams>;
/**
* measure container
*/
measures: SmoMeasureParamsSer[];
/**
* array of modifiers like slurs
*/
modifiers: StaffModifierBaseSer[];
/**
* Associated part information for this stave
*/
partInfo: SmoPartInfoParamsSer;
/**
* text brackets are another kind of modifier
*/
textBrackets: SmoStaffTextBracketParamsSer[];
/**
* guitar tablature
*/
tabStaves: SmoTabStave[];
}
/**
* A staff is a line of music that can span multiple measures.
* A system is a line of music for each staff in the score. So a staff
* spans multiple systems.
* A staff modifier connects 2 points in the staff.
* @category SmoObject
* */
export declare class SmoSystemStaff implements SmoObjectParams {
/**
* Gets the instrument assigned to a given measure
* @param measureInstrumentMap
* @param measureIndex
* @returns
*/
static getStaffInstrument(measureInstrumentMap: Record<number, SmoInstrument>, measureIndex: number): SmoInstrument;
static getStaffInstrumentArray(measureInstrumentMap: Record<number, SmoInstrumentParams>): SmoInstrumentMeasure[];
staffId: number;
renumberingMap: Record<number, number>;
keySignatureMap: Record<number, string>;
partInfo: SmoPartInfo;
measureInstrumentMap: Record<number, SmoInstrument>;
measures: SmoMeasure[];
modifiers: StaffModifierBase[];
textBrackets: SmoStaffTextBracket[];
bracketMap: Record<number, SVGSVGElement[]>;
tabStaves: SmoTabStave[];
attrs: SmoAttrs;
ctor: string;
_mappedStaffId: number;
static get defaults(): SmoSystemStaffParams;
setMappedStaffId(value: number): void;
getMappedStaffId(): number;
constructor(params: SmoSystemStaffParams);
/**
* records need to be serialized separately from other elements in parameters
*
* @static
* @type {string[]}
* @memberof SmoSystemStaff
*/
static serializableElements: string[];
static recordElements: string[];
static get defaultParameters(): string[];
get renderableModifiers(): StaffModifierBase[];
serialize(options: SmoStaffSerializationOptions): SmoSystemStaffParamsSer;
static deserialize(jsonObj: SmoSystemStaffParamsSer): SmoSystemStaff;
/**
* We have created a score with staff mappings. Update the selectors in staff modifiers so that
* 'from' in the staff slot is 'to'
*/
mapStaffFromTo(from: number, to: number): void;
updateMeasureFormatsForPart(): void;
/**
* Get the active instrument at the given measure
* @param measureIndex
* @returns
*/
getStaffInstrument(measureIndex: number): SmoInstrument;
getInstrumentList(): SmoInstrument[];
updateInstrumentOffsets(): void;
isRest(index: number): boolean;
/**
* for the purposes of breaking up multimeasure rests, isRepeat is true if
* the next bar has a start repeat, or the current bar has an end repeat.
* @param index
* @returns
*/
isRepeat(index: number): boolean;
isRepeatSymbol(index: number): boolean;
isRehearsal(index: number): boolean;
findSimlarOverlap(modifier: StaffModifierBase): StaffModifierBase[];
removeTabStaves(delList: SmoTabStave[]): void;
updateTabStave(ts: SmoTabStave): void;
getTabStaveForMeasure(selector: SmoSelector): SmoTabStave | undefined;
getTabStavesForMeasureRow(measures: SmoMeasure[]): SmoTabStave[];
addStaffModifier(modifier: StaffModifierBase): void;
removeStaffModifier(modifier: StaffModifierBase): void;
getVoltaMap(startIndex: number, endIndex: number): SmoVolta[];
getVoltasForMeasure(ix: number): SmoVolta[];
getModifiersAt(selector: SmoSelector): StaffModifierBase[];
getModifier(modData: any): StaffModifierBase | undefined;
setLyricFont(fontInfo: FontInfo): void;
setLyricAdjustWidth(adjustNoteWidth: boolean): void;
setChordFont(fontInfo: FontInfo): void;
setChordAdjustWidth(adjustNoteWidth: boolean): void;
addTextBracket(bracketParams: SmoStaffTextBracket): void;
removeTextBracket(bracketParams: SmoStaffTextBracket): void;
getTextBracketsStartingAt(selector: SmoSelector): SmoStaffTextBracket[];
getSlursStartingAt(selector: SmoSelector): StaffModifierBase[];
getSlursEndingAt(selector: SmoSelector): StaffModifierBase[];
getTiesStartingAt(selector: SmoSelector): SmoTie[];
getTiesEndingAt(selector: SmoSelector): StaffModifierBase[];
getPedalMarkingsContaining(selector: SmoSelector): StaffModifierBase[];
getModifiers(): StaffModifierBase[];
applyBeams(): void;
addRehearsalMark(index: number, parameters: SmoRehearsalMarkParams): void;
removeTempo(index: number): void;
addTempo(tempo: SmoTempoTextParams, index: number): void;
removeRehearsalMark(index: number): void;
/**
* Sync the staff modifier indices between the full score and the score view, which may
* have fewer staves
* @param measureIndex
* @param ostaff
*/
syncStaffModifiers(measureIndex: number, ostaff: SmoSystemStaff): void;
deleteMeasure(index: number): void;
addKeySignature(measureIndex: number, key: string): void;
_updateKeySignatures(): void;
numberMeasures(): void;
addDefaultMeasure(index: number, params: SmoMeasure): void;
addMeasure(index: number, measure: SmoMeasure): void;
}
//# sourceMappingURL=systemStaff.d.ts.map