smoosic 1.0.37 → 1.0.39

package/release/styles/dialogs.css

@@ -1196,6 +1196,10 @@ button.translate-submit-button {
 #render-progress[value]::-webkit-progress-value {
   background: #F70;
 }
+body.progress-modal.printing #render-progress,
+body.progress-modal.printing .navbar-expand {
+  display: none;
+}
 body.progress-modal #render-progress {
   display: block;
 }

package/src/application/exports.ts

@@ -37,7 +37,7 @@ import { SuiTransposeScoreDialogVue} from '../ui/dialogs/transposeScore';
 import { SuiMeasureFormatDialogVue } from '../ui/dialogs/measureFormat';
 import { SuiInsertMeasuresVue } from '../ui/dialogs/addMeasure';
 import { SuiInstrumentDialogVue } from '../ui/dialogs/instrument';
-import { SuiTimeSignatureDialog } from '../ui/dialogs/timeSignature';
+import { SuiTimeSignatureDialogVue } from '../ui/dialogs/timeSignature';
 import { SuiTempoDialog } from '../ui/dialogs/tempo';
 import { SuiNoteHeadDialog } from '../ui/dialogs/noteHead';
 import { SuiEndingsDialogVue } from '../ui/dialogs/endings';
@@ -153,7 +153,7 @@ import { SmoOperation } from '../smo/xform/operations';
 import { ScoreRoadMapBuilder } from '../smo/xform/roadmap';
 import {
     SmoRehearsalMark, SmoMeasureFormat, SmoBarline, SmoRepeatSymbol,
-    SmoVolta, SmoMeasureText, SmoTempoText, TimeSignature, measureModifierDynamicCtorInit
+    SmoVolta, SmoMeasureText, SmoTempo, SmoTimeSignature, measureModifierDynamicCtorInit
 } from '../smo/data/measureModifiers';
 import { SmoToXml } from '../smo/mxml/smoToXml';
 import { MidiToSmo } from '../smo/midi/midiToSmo';
@@ -357,7 +357,7 @@ export const Smo = {
   GlobalLayoutNumberAttributesArray,
   SuiTransposeScoreDialogVue,
   SuiScoreFontDialogVue, SuiPageLayoutDialogVue, SuiMeasureFormatDialogVue, SuiInsertMeasuresVue,
-  SuiTimeSignatureDialog,SuiTextBlockDialog, SuiLyricDialog, SuiChordChangeDialog,
+  SuiTimeSignatureDialogVue,SuiTextBlockDialog, SuiLyricDialog, SuiChordChangeDialog,
   SuiSlurAttributesDialog, SuiPedalMarkingDialog, SuiTieAttributesDialog, SuiVoltaAttributeDialog,
   SuiHairpinAttributesDialog, SuiStaffGroupDialogVue,
   SuiScorePreferencesDialogVue,
@@ -400,7 +400,7 @@ SuiPitchComposite,
   // score modifiers
   SmoSystemGroup, SmoAudioPlayerSettings, SmoTextGroup,
   // measure modifiers
-  SmoRehearsalMark, SmoMeasureFormat, SmoBarline, SmoRepeatSymbol,  SmoVolta, SmoMeasureText, SmoTempoText, TimeSignature,
+  SmoRehearsalMark, SmoMeasureFormat, SmoBarline, SmoRepeatSymbol,  SmoVolta, SmoMeasureText, SmoTempo, SmoTimeSignature,
   measureModifierDynamicCtorInit,
   // note modifiers
   SmoOrnament, noteModifierDynamicCtorInit,

package/src/render/audio/musicCursor.ts

@@ -72,7 +72,7 @@ export const  defaultClearAudioAnimationHandler = (delay: number) => {
     }
     const screenBox = SvgHelpers.boxPoints(x, y, width, height);
     const fillParams: Record<string, string> = {};
-    console.log(`topbox xy ${measure.svg.logicalBox.x}, ${measure.svg.logicalBox.y} x ${x}, ${y}`);
+    // console.log(`topbox xy ${measure.svg.logicalBox.x}, ${measure.svg.logicalBox.y} x ${x}, ${y}`);
     fillParams['fill-opacity'] = '0.5';
     fillParams['fill'] = '#4444ff';
     const ctx = context.getContext();

package/src/render/sui/NoteEntryCaret.ts

@@ -203,7 +203,10 @@ export class NoteEntryCaret {
 		}
 
 		const staveNote = vexNote as StaveNote;
-		const noteHeads = staveNote.noteHeads;
+    if (!staveNote.noteHeads) {
+      return;
+    }
+		const noteHeads = staveNote.noteHeads;    
 
 		this.vexNoteLeftDisplacedHeadPx = staveNote.getMetrics().leftDisplacedHeadPx;
 		this.vexNoteRightDisplacedHeadPx = staveNote.getMetrics().rightDisplacedHeadPx;

package/src/render/sui/formatter.ts

@@ -16,7 +16,7 @@ import { SmoStaffHairpin, SmoStaffTextBracket, SmoTabStave } from '../../smo/dat
 import { layoutDebug } from './layoutDebug';
 import { ScaledPageLayout, SmoLayoutManager, SmoPageLayout } from '../../smo/data/scoreModifiers';
 import { SmoMeasure, ISmoBeamGroup } from '../../smo/data/measure';
-import { TimeSignature, SmoTempoText } from '../../smo/data//measureModifiers';
+import { SmoTimeSignature, SmoTempo } from '../../smo/data//measureModifiers';
 import { SvgPageMap } from './svgPageMap';
 import { VexFlow, defaultMeasurePadding } from '../../common/vex';
 import { TextFormatter } from '../../common/textformatter';
@@ -831,7 +831,7 @@ export class SuiLayoutFormatter {
    * @param score 
    */
   calculateBeginningSymbols(systemIndex: number, measure: SmoMeasure,
-    clefLast: string, keySigLast: string, timeSigLast: TimeSignature, tempoLast: SmoTempoText) {
+    clefLast: string, keySigLast: string, timeSigLast: SmoTimeSignature, tempoLast: SmoTempo) {
     // The key signature is set based on the transpose index already, i.e. an Eb part in concert C already has 3 sharps.
     const xposeScore = this.score?.preferences?.transposingScore && (this.score?.isPartExposed() === false);
     // const xposeOffset = xposeScore ? measure.transposeIndex : 0;
@@ -850,7 +850,7 @@ export class SuiLayoutFormatter {
       measure.svg.forceTempo = tempo.display && measure.svg.rowInSystem === 0;
     } else if (tempo && tempoLast) {
       // otherwise get tempo from the measure prior.  But only one tempo per system.
-      if (!SmoTempoText.eq(tempo, tempoLast) && measure.svg.rowInSystem === 0) {
+      if (!SmoTempo.eq(tempo, tempoLast) && measure.svg.rowInSystem === 0) {
         measure.svg.forceTempo = tempo.display;
       }
     } else if (tempo) {

package/src/render/sui/mapper.ts

@@ -159,7 +159,7 @@ export abstract class SuiMapper {
         this.localModifiers.push({ index, selection: sel, modifier: volta, box: volta.logicalBox ?? SvgBox.default });
         index += 1;
       });
-      sel.measure.getModifiersByType('SmoTempoText').forEach((tempo) => {
+      sel.measure.getModifiersByType('SmoTempo').forEach((tempo) => {
         this.localModifiers.push({ index, selection: sel, modifier: tempo, box: tempo.logicalBox ?? SvgBox.default });
         index += 1;
       });

package/src/render/sui/scoreView.ts

@@ -23,8 +23,8 @@ import { ScoreRenderParams } from './scoreRender';
 import { SmoOperation } from '../../smo/xform/operations';
 import { SuiAudioPlayer } from '../audio/player';
 import { SuiAudioAnimationParams } from '../audio/musicCursor';
-import { SmoTempoText } from '../../smo/data/measureModifiers';
-import { TimeSignature } from '../../smo/data/measureModifiers';
+import { SmoTempo } from '../../smo/data/measureModifiers';
+import { SmoTimeSignature } from '../../smo/data/measureModifiers';
 import { ref, Ref } from 'vue';
 import { SvgBox, SvgPoint } from '../../smo/data/common';
 import { layoutDebug } from './layoutDebug';
@@ -685,8 +685,8 @@ export abstract class SuiScoreView implements layoutProvider {
         }
         nStave.measures.forEach((measure: SmoMeasure, ix) => {
           const srcMeasure = srcStave.measures[ix];
-          measure.tempo = new SmoTempoText(srcMeasure.tempo.serialize());
-          measure.timeSignature = new TimeSignature(srcMeasure.timeSignature);
+          measure.tempo = new SmoTempo(srcMeasure.tempo.serialize());
+          measure.timeSignature = new SmoTimeSignature(srcMeasure.timeSignature);
           measure.keySignature = srcMeasure.keySignature;
         });
         staffMap.push(i);

package/src/render/sui/scoreViewOperations.ts

@@ -14,8 +14,8 @@ import { SmoTextGroup } from '../../smo/data/scoreText';
 import { SmoDynamicText, SmoNoteModifierBase, SmoGraceNote, SmoArticulation, 
   SmoOrnament, SmoLyric, SmoMicrotone, SmoArpeggio, SmoArpeggioType, SmoClefChange, 
   SmoTabNote} from '../../smo/data/noteModifiers';
-import { SmoTempoText, SmoVolta, SmoBarline, SmoRepeatSymbol, 
-  SmoRehearsalMark, SmoMeasureFormat, TimeSignature } from '../../smo/data/measureModifiers';
+import { SmoTempo, SmoVolta, SmoBarline, SmoRepeatSymbol, 
+  SmoRehearsalMark, SmoMeasureFormat, SmoTimeSignature } from '../../smo/data/measureModifiers';
 import { UndoBuffer } from '../../smo/xform/undo';
 import {
   SmoOperation, createStaffModifierType, MakeTupletOperation
@@ -525,7 +525,7 @@ export class SuiScoreViewOperations extends SuiScoreView {
    * Set the time signature for a selection
    * @param timeSignature actual time signature
    */
-  async setTimeSignature(timeSignature: TimeSignature): Promise<void> {
+  async setTimeSignature(timeSignature: SmoTimeSignature): Promise<void> {
     this._undoScore('Set time signature');
     const selections = this.tracker.selections;
     const altSelections = this._getEquivalentSelections(selections);
@@ -627,9 +627,9 @@ export class SuiScoreViewOperations extends SuiScoreView {
    * @param scoreMode if true, update whole score.  Else selections
    * @returns 
    */
-  async updateTempoScore(measure: SmoMeasure, tempo: SmoTempoText, scoreMode: boolean, selectionMode: boolean): Promise<void> {
+  async updateTempoScore(measure: SmoMeasure, tempo: SmoTempo, scoreMode: boolean, selectionMode: boolean): Promise<void> {
     let measureIndex = 0;    
-    const originalTempo = new SmoTempoText(measure.tempo);
+    const originalTempo = new SmoTempo(measure.tempo);
     this._undoColumn('update tempo', measure.measureNumber.measureIndex);
     let startMeasure = measure.measureNumber.measureIndex;
     let endMeasure = this.score.staves[0].measures.length;
@@ -641,14 +641,14 @@ export class SuiScoreViewOperations extends SuiScoreView {
       }
     }
     // If we are only changing the position of the text, it only affects the tempo measure.
-    if (SmoTempoText.eq(originalTempo, tempo) && tempo.yOffset !== originalTempo.yOffset && endMeasure > startMeasure) {
+    if (SmoTempo.eq(originalTempo, tempo) && tempo.yOffset !== originalTempo.yOffset && endMeasure > startMeasure) {
       endMeasure = startMeasure + 1;          
     }
     for (measureIndex = startMeasure; measureIndex < endMeasure; ++measureIndex) {
       if (!scoreMode && !selectionMode) {
         // If not whole score or selections, change until the tempo doesn't match previous measure's tempo (next tempo change)
         const compMeasure = this.score.staves[0].measures[measureIndex];
-        if (SmoTempoText.eq(originalTempo, compMeasure.tempo) || displayed === false) {
+        if (SmoTempo.eq(originalTempo, compMeasure.tempo) || displayed === false) {
           const sel = SmoSelection.measureSelection(this.score, 0, measureIndex);
           const altSel = SmoSelection.measureSelection(this.storeScore, 0, measureIndex);
           if (sel && sel.measure.tempo.display && !displayed) {
@@ -706,17 +706,17 @@ export class SuiScoreViewOperations extends SuiScoreView {
    * default tempo, or the previously-set tempo.
    * @param scoreMode whether to reset entire score
    */
-  async removeTempo(measure: SmoMeasure, tempo: SmoTempoText, scoreMode: boolean, selectionMode: boolean): Promise<void> {
+  async removeTempo(measure: SmoMeasure, tempo: SmoTempo, scoreMode: boolean, selectionMode: boolean): Promise<void> {
     const startSelection = this.tracker.selections[0];
     if (startSelection.selector.measure > 0) {
       const measureIx = startSelection.selector.measure - 1;
       const target = startSelection.staff.measures[measureIx];
       const tempo = target.getTempo();
-      const newTempo = new SmoTempoText(tempo);
+      const newTempo = new SmoTempo(tempo);
       newTempo.display = false;
       this.updateTempoScore(measure, newTempo, scoreMode, selectionMode);
     } else {
-      this.updateTempoScore(measure, new SmoTempoText(SmoTempoText.defaults), scoreMode, selectionMode);
+      this.updateTempoScore(measure, new SmoTempo(SmoTempo.defaults), scoreMode, selectionMode);
     }
     await this.renderer.updatePromise();
   }

package/src/render/sui/textEdit.ts

@@ -850,7 +850,9 @@ export class SuiChordEditor extends SuiTextEditor {
     if (this.svgText !== null && this.svgText.blocks.length > this.textPos && this.textPos >= 0) {
       this.textType = this.svgText.blocks[this.textPos].textType;
     }
-    evdata.preventDefault(); // prevent browser scroll
+    if (typeof(evdata.preventDefault) === 'function') {
+      evdata.preventDefault(); // prevent browser scroll
+    }
 
     return edited;
   }

package/src/render/vex/vxMeasure.ts

@@ -543,15 +543,21 @@ export class VxMeasure implements VxMeasureIf {
     this.stave = createStave(smoVexStaveParams);
     if (this.smoMeasure.svg.forceTimeSignature) {
       const ts = this.smoMeasure.timeSignature;
-      let tsString = ts.timeSignature;
+      
       if (this.smoMeasure.timeSignature.useSymbol && ts.actualBeats === 4 && ts.beatDuration === 4) {
-        tsString = 'C';
+        this.stave.addTimeSignature('C');
       } else if (this.smoMeasure.timeSignature.useSymbol && ts.actualBeats === 2 && ts.beatDuration === 4) {
-        tsString = 'C|';
-      } else if (this.smoMeasure.timeSignature.displayString.length) {
-        tsString = this.smoMeasure.timeSignature.displayString;
+        this.stave.addTimeSignature('C|');
+      } else  {
+        let tsString = this.smoMeasure.timeSignature.displayString.length ? this.smoMeasure.timeSignature.displayString : ts.timeSignature;
+        const tsStrings = tsString.split('+');  
+        for (let i = 0; i < tsStrings.length; i++) {
+          const tsString = tsStrings[i].trim();
+          if (tsString.length) {
+            this.stave.addTimeSignature(tsStrings[i].trim());
+          }
+        }
       }
-      this.stave.addTimeSignature(tsString);
     }
     // Connect it to the rendering context and draw!
     this.stave.setContext(this.context.getContext());

package/src/smo/data/measure.ts

@@ -12,9 +12,9 @@
 import { smoSerialize } from '../../common/serializationHelpers';
 import { SmoMusic } from './music';
 import {
-  SmoBarline, SmoMeasureModifierBase, SmoRepeatSymbol, SmoTempoText, SmoMeasureFormat,
-  SmoVolta, SmoRehearsalMarkParams, SmoRehearsalMark, SmoTempoTextParams, TimeSignature,
-  TimeSignatureParametersSer, SmoMeasureFormatParamsSer, SmoTempoTextParamsSer
+  SmoBarline, SmoMeasureModifierBase, SmoRepeatSymbol, SmoTempo, SmoMeasureFormat,
+  SmoVolta, SmoRehearsalMarkParams, SmoRehearsalMark, SmoTempoParams, SmoTimeSignature,
+  TimeSignatureParametersSer, SmoMeasureFormatParamsSer, SmoTempoParamsSer
 } from './measureModifiers';
 import { SmoNote, NoteType, SmoNoteParamsSer } from './note';
 import { SmoTuplet, SmoTupletParamsSer, SmoTupletParams, SmoTupletTreeParamsSer, SmoTupletTree } from './tuplet';
@@ -148,7 +148,7 @@ export const SmoMeasureStringParams: SmoMeasureStringParam[] = ['keySignature'];
  * @category SmoObject
  */
 export interface SmoMeasureParams {
-  timeSignature: TimeSignature,
+  timeSignature: SmoTimeSignature,
   keySignature: string,
   tupletTrees: SmoTupletTree[],
   transposeIndex: number,
@@ -158,7 +158,7 @@ export interface SmoMeasureParams {
   clef: Clef,
   voices: SmoVoice[],
   activeVoice: number,
-  tempo: SmoTempoText,
+  tempo: SmoTempo,
   format: SmoMeasureFormat | null,
   modifiers: SmoMeasureModifierBase[],
   repeatSymbol: boolean,
@@ -218,7 +218,7 @@ export interface SmoMeasureParamsSer {
   /**
    * tempo at this point
    */
-  tempo: SmoTempoTextParamsSer
+  tempo: SmoTempoParamsSer
 
 }
 
@@ -244,8 +244,8 @@ function isSmoMeasureParamsSer(params: Partial<SmoMeasureParamsSer>):params is S
  * @category SmoObject
  */
 export class SmoMeasure implements SmoMeasureParams, TickMappable {
-  static get timeSignatureDefault(): TimeSignature {
-    return new TimeSignature(TimeSignature.defaults);
+  static get timeSignatureDefault(): SmoTimeSignature {
+    return new SmoTimeSignature(SmoTimeSignature.defaults);
   }
   static defaultDupleDuration: number = 4096;
   static defaultTripleDuration: number = 2048 * 3;
@@ -268,7 +268,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     voices: [],
     format: new SmoMeasureFormat(SmoMeasureFormat.defaults),
     activeVoice: 0,
-    tempo: new SmoTempoText(SmoTempoText.defaults),
+    tempo: new SmoTempo(SmoTempo.defaults),
     repeatSymbol: false,
     repeatCount: 0  
   }
@@ -281,7 +281,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   static get defaults(): SmoMeasureParams {
     const proto: any = JSON.parse(JSON.stringify(SmoMeasure._defaults));
     proto.format = new SmoMeasureFormat(SmoMeasureFormat.defaults);
-    proto.tempo = new SmoTempoText(SmoTempoText.defaults);
+    proto.tempo = new SmoTempo(SmoTempo.defaults);
     proto.modifiers.push(new SmoBarline({
       position: SmoBarline.positions.start,
       barline: SmoBarline.barlines.singleBar
@@ -294,11 +294,11 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   }
   // @ignore
   static convertLegacyTimeSignature(ts: string) {
-    const rv = new TimeSignature(TimeSignature.defaults);
+    const rv = new SmoTimeSignature(SmoTimeSignature.defaults);
     rv.timeSignature = ts;
     return rv;
   }
-  timeSignature: TimeSignature = SmoMeasure.timeSignatureDefault;
+  timeSignature: SmoTimeSignature = SmoMeasure.timeSignatureDefault;
   /**
    * Overrides display of actual time signature, in the case of
    * pick-up notes where the actual and displayed durations are different
@@ -329,7 +329,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * the active voice in the editor, if there are multiple voices
    *  */
   activeVoice: number = 0;
-  tempo: SmoTempoText;
+  tempo: SmoTempo;
   beamGroups: ISmoBeamGroup[] = [];
   lines: number = 5;
   /**
@@ -351,7 +351,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * @param params
    */
   constructor(params: SmoMeasureParams) {
-    this.tempo = new SmoTempoText(SmoTempoText.defaults);
+    this.tempo = new SmoTempo(SmoTempo.defaults);
     this.svg = {
       staffWidth: 0,
       unjustifiedWidth: 0,
@@ -392,7 +392,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     this.repeatSymbol = params.repeatSymbol;
     this.measureNumber = JSON.parse(JSON.stringify(params.measureNumber));
     if (params.tempo) {
-      this.tempo = new SmoTempoText(params.tempo);
+      this.tempo = new SmoTempo(params.tempo);
     }
     // Handle legacy time signature format
     if (params.timeSignature) {
@@ -400,7 +400,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       if (typeof (tsAny) === 'string') {
         this.timeSignature = SmoMeasure.convertLegacyTimeSignature(tsAny);
       } else {
-        this.timeSignature = TimeSignature.createFromPartial(tsAny);
+        this.timeSignature = SmoTimeSignature.createFromPartial(tsAny);
       }
     }
     this.voices = params.voices ? params.voices : [];
@@ -454,7 +454,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   // Return true if the time signatures are the same, for display purposes (e.g. if a time sig change
   // is required)
   */
-  static timeSigEqual(o1: TimeSignature, o2: TimeSignature) {
+  static timeSigEqual(o1: SmoTimeSignature, o2: SmoTimeSignature) {
     return o1.timeSignature === o2.timeSignature && o1.useSymbol === o2.useSymbol;
   }
   /**
@@ -568,7 +568,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       } else if (modifier.ctor === 'SmoBarline' && (modifier as SmoBarline).position === SmoBarline.positions.end
         && (modifier as SmoBarline).barline === SmoBarline.barlines.singleBar) {
         ser = false;
-      } else if (modifier.ctor === 'SmoTempoText') {
+      } else if (modifier.ctor === 'SmoTempo') {
         // we don't save tempo text as a modifier anymore
         ser = false;
       } else if ((modifier as SmoRepeatSymbol).ctor === 'SmoRepeatSymbol' && (modifier as SmoRepeatSymbol).position === SmoRepeatSymbol.positions.start
@@ -639,9 +639,9 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
 
     // explode column-mapped
     if (jsonObj.tempo) {
-      params.tempo = SmoTempoText.deserialize(jsonObj.tempo);
+      params.tempo = SmoTempo.deserialize(jsonObj.tempo);
     } else {
-      params.tempo = new SmoTempoText(SmoTempoText.defaults);
+      params.tempo = new SmoTempo(SmoTempo.defaults);
     }
 
     // timeSignatureString is now part of timeSignature.  upconvert old scores
@@ -654,13 +654,14 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       if (timeSignatureString.length) {
         jsonObj.timeSignature.displayString = timeSignatureString;  
       }
-      params.timeSignature = TimeSignature.deserialize(jsonObj.timeSignature);
+      jsonObj.timeSignature.ctor = 'SmoTimeSignature';
+      params.timeSignature = SmoTimeSignature.deserialize(jsonObj.timeSignature);
     } else {
-      const tparams = TimeSignature.defaults;
+      const tparams = SmoTimeSignature.defaults;
       if (timeSignatureString.length) {
         tparams.displayString = timeSignatureString;
       }
-      params.timeSignature = new TimeSignature(tparams);
+      params.timeSignature = new SmoTimeSignature(tparams);
     }
     params.keySignature = jsonObj.keySignature ?? 'C';
     params.voices = voices;
@@ -725,12 +726,12 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     const measure = new SmoMeasure(params);
     // Handle migration for measure-mapped parameters
     measure.modifiers.forEach((mod) => {
-      if (mod.ctor === 'SmoTempoText') {
-        measure.tempo = (mod as SmoTempoText);
+      if (mod.ctor === 'SmoTempo') {
+        measure.tempo = (mod as SmoTempo);
       }
     });
     if (!measure.tempo) {
-      measure.tempo = new SmoTempoText(SmoTempoText.defaults);
+      measure.tempo = new SmoTempo(SmoTempo.defaults);
     }
 
 
@@ -747,8 +748,8 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     // Ordinarily, the key/tempo/time is mapped to the stave, but since we are pasting measure-by
     // measure here, we want to preserve it.
     clonedMeasure.keySignature = measure.keySignature;
-    clonedMeasure.timeSignature = new TimeSignature(measure.timeSignature);
-    clonedMeasure.tempo = new SmoTempoText(measure.tempo);
+    clonedMeasure.timeSignature = new SmoTimeSignature(measure.timeSignature);
+    clonedMeasure.tempo = new SmoTempo(measure.tempo);
     return clonedMeasure;
   }
   hasNonRestNotes(): boolean {
@@ -834,7 +835,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
   static get emptyMeasureNoteType(): NoteType {
     return SmoMeasure._emptyMeasureNoteType;
   }
-  static timeSignatureNotes(timeSignature: TimeSignature, clef: Clef) {
+  static timeSignatureNotes(timeSignature: SmoTimeSignature, clef: Clef) {
     const pitch = SmoMeasure.defaultPitchForClef[clef];
     const maxTicks = SmoMusic.timeSignatureToTicks(timeSignature.timeSignature);
     const noteTick = 8192 / (timeSignature.beatDuration / 2);
@@ -869,7 +870,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
    * @returns 
    */
   static getDefaultNotes(params: SmoMeasureParams): SmoNote[] {
-    return SmoMeasure.timeSignatureNotes(new TimeSignature(params.timeSignature), params.clef);
+    return SmoMeasure.timeSignatureNotes(new SmoTimeSignature(params.timeSignature), params.clef);
   }
 
   /**
@@ -888,7 +889,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     smoSerialize.serializedMerge(SmoMeasure.defaultAttributes, params, obj);
     // Don't copy column-formatting options to new measure in new column
     smoSerialize.serializedMerge(SmoMeasure.formattingOptions, SmoMeasure.defaults, obj);
-    obj.timeSignature = new TimeSignature(params.timeSignature);
+    obj.timeSignature = new SmoTimeSignature(params.timeSignature);
     // The measure expects to get concert KS in constructor and adjust for instrument.  So do the
     // opposite.
     obj.keySignature = SmoMusic.vexKeySigWithOffset(obj.keySignature, -1 * obj.transposeIndex);
@@ -1019,7 +1020,6 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
       }
     }
     const voices: SmoVoice[] = [];
-    const tuplets: SmoTuplet[] = [];
     for (var i = 0; i < this.voices.length; ++i) {
       const voice = this.voices[i];
       const newNotes: SmoNote[] = [];
@@ -1529,18 +1529,18 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     return this.modifiers.filter((mm) => type === mm.attrs.type);
   }
 
-  setTempo(params: SmoTempoTextParams) {
-    this.tempo = new SmoTempoText(params);
+  setTempo(params: SmoTempoParams) {
+    this.tempo = new SmoTempo(params);
   }
   /**
-   * Set measure tempo to the default {@link SmoTempoText}
+   * Set measure tempo to the default {@link SmoTempo}
    */
   resetTempo() {
-    this.tempo = new SmoTempoText(SmoTempoText.defaults);
+    this.tempo = new SmoTempo(SmoTempo.defaults);
   }
   getTempo() {
     if (typeof (this.tempo) === 'undefined') {
-      this.tempo = new SmoTempoText(SmoTempoText.defaults);
+      this.tempo = new SmoTempo(SmoTempo.defaults);
     }
     return this.tempo;
   }