smoosic 1.0.36 → 1.0.38

package/src/smo/data/score.ts

@@ -9,7 +9,7 @@ import { Clef, SvgDimensions } from './common';
 import { SmoMeasure, SmoMeasureParams, ColumnMappedParams, SmoMeasureParamsSer } from './measure';
 import { SmoNoteModifierBase } from './noteModifiers';
 import {
-  SmoTempoText, SmoMeasureFormat, SmoMeasureModifierBase, TimeSignature, TimeSignatureParameters,
+  SmoTempo, SmoMeasureFormat, SmoMeasureModifierBase, SmoTimeSignature, TimeSignatureParameters,
   SmoMeasureFormatParamsSer
 } from './measureModifiers';
 import { StaffModifierBase, SmoInstrument } from './staffModifiers';
@@ -153,8 +153,8 @@ export function isEmptyTextBlock(params: Partial<SmoTextGroupParamsSer>): params
  */
 export interface ColumnParamsMapType {
   keySignature: Record<number, string>,
-  tempo: Record<number, SmoTempoText>,
-  timeSignature: Record<number, TimeSignature>,
+  tempo: Record<number, SmoTempo>,
+  timeSignature: Record<number, SmoTimeSignature>,
   renumberingMap: Record<number, number>
 }
 
@@ -351,8 +351,8 @@ export class SmoScore {
    */
   serializeColumnMapped(func: (measure: SmoMeasure) => ColumnMappedParams) {
     const keySignature: Record<number, string> = {};
-    const tempo: Record<number, SmoTempoText> = {};
-    const timeSignature: Record<number, TimeSignature> = {};
+    const tempo: Record<number, SmoTempo> = {};
+    const timeSignature: Record<number, SmoTimeSignature> = {};
     const renumberingMap: Record<number, number> = {};
     let previous: ColumnMappedParams | null = null;
     this.staves[0].measures.forEach((measure) => {
@@ -381,11 +381,11 @@ export class SmoScore {
           previous!.keySignature = current.keySignature;
           keySignature[ix] = current.keySignature;
         }
-        if (!(TimeSignature.equal(current.timeSignature, previous!.timeSignature))) {
+        if (!(SmoTimeSignature.equal(current.timeSignature, previous!.timeSignature))) {
           previous!.timeSignature = current.timeSignature;
           timeSignature[ix] = current.timeSignature;
         }
-        if (!(SmoTempoText.eq(current.tempo, previous!.tempo))) {
+        if (!(SmoTempo.eq(current.tempo, previous!.tempo))) {
           previous!.tempo = current.tempo;
           tempo[ix] = current.tempo;
         }
@@ -393,7 +393,45 @@ export class SmoScore {
     });
     return { keySignature, tempo, timeSignature, renumberingMap };
   }
-
+  static fixLegacyColumnMappedCtor(scoreObj: any){
+    if (!scoreObj.columnAttributeMap) {
+      return;
+    }
+    if (!scoreObj.columnAttributeMap.tempo) {
+      return;
+    }
+    const tempoKeys = Object.keys(scoreObj.columnAttributeMap.tempo);
+    tempoKeys.forEach((key) => {
+      const t = scoreObj.columnAttributeMap.tempo[key];
+      t.ctor = 'SmoTempo';
+    });
+    const tsKeys = Object.keys(scoreObj.columnAttributeMap.timeSignature);
+    tsKeys.forEach((key) => {
+      const val = scoreObj.columnAttributeMap.timeSignature[key];
+      // Very legacy time signature format was just a string like 4/4, 3/8 etc.
+      if (typeof(val) === 'string') {
+        const nums = val.split('/');
+        const num = parseInt(nums[0], 10);
+        const denom = parseInt(nums[1], 10);
+        scoreObj.columnAttributeMap.timeSignature[key] = { times: [{ actualBeats: num, beatDuration: denom }], ctor: 'SmoTimeSignature' };
+      } else {
+        const ts =  val;      
+        ts.ctor = 'SmoTimeSignature';
+        // map legacy time signature format to compound time signature format
+        let beatDuration = 4;
+        if (ts.beatDuration && !isNaN(ts.beatDuration)) {
+          beatDuration = ts.beatDuration;
+        }
+        if (ts.actualBeats && !isNaN(ts.actualBeats)) {        
+          ts.times = [{ actualBeats: ts.actualBeats, beatDuration }];
+        }
+        // Default will have nothing serialized
+        if (!ts.times) {
+          ts.times = [{ actualBeats: 4, beatDuration: 4 }];
+        }
+      }
+    });
+  }
   /**
    * Column-mapped attributes stay the same in each measure until
    * changed, like key-signatures.  We don't store each measure value to
@@ -407,6 +445,7 @@ export class SmoScore {
     if (!scoreObj.columnAttributeMap) {
       return;
     }
+    SmoScore.fixLegacyColumnMappedCtor(scoreObj);
     const attrs = Object.keys(scoreObj.columnAttributeMap);
     scoreObj.staves.forEach((staff: any) => {
       const attrIxMap: any = {};
@@ -429,12 +468,12 @@ export class SmoScore {
           }
           // legacy timeSignature format was just a string 2/4, 3/8 etc.
           if (attr === 'timeSignature') {
-            const ts = new TimeSignature(TimeSignature.defaults);
+            const ts = new SmoTimeSignature(SmoTimeSignature.defaults);
             if (typeof (curValue) === 'string') {
               ts.timeSignature = curValue;
               measure[attr] = ts;
             } else {
-              measure[attr] = TimeSignature.createFromPartial(curValue);
+              measure[attr] = SmoTimeSignature.createFromPartial(curValue);
             }
           } else {
             measure[attr] = curValue;
@@ -878,7 +917,7 @@ export class SmoScore {
     if (measureIndex > 0) {
       const measure = this.staves[0].measures[measureIndex];
       const prev = this.staves[0].measures[measureIndex - 1];
-      if (!start && !TimeSignature.equal(measure.timeSignature, prev.timeSignature)) {
+      if (!start && !SmoTimeSignature.equal(measure.timeSignature, prev.timeSignature)) {
         return false;
       }
       if (!start && measure.keySignature !== prev.keySignature) {

package/src/smo/data/systemStaff.ts

@@ -9,7 +9,7 @@ import { SmoObjectParams, SmoAttrs, MeasureNumber, getId,
    Pitch, ElementLike } from './common';
 import { SmoMusic } from './music';
 import { SmoMeasure, SmoMeasureParamsSer } from './measure';
-import { SmoMeasureFormat, SmoRehearsalMark, SmoRehearsalMarkParams, SmoTempoTextParams, SmoVolta, SmoBarline } from './measureModifiers';
+import { SmoMeasureFormat, SmoRehearsalMark, SmoRehearsalMarkParams, SmoTempoParams, SmoVolta, SmoBarline } from './measureModifiers';
 import { SmoInstrumentParams, StaffModifierBase, SmoInstrument, SmoInstrumentMeasure, SmoInstrumentStringParams, SmoInstrumentNumParams, 
   SmoTie, SmoStaffTextBracket, SmoStaffTextBracketParamsSer, 
   StaffModifierBaseSer, SmoTabStave, SmoStaffHairpin, TieLine,
@@ -851,7 +851,7 @@ export class SmoSystemStaff implements SmoObjectParams {
     this.measures[index].resetTempo();
   }
 
-  addTempo(tempo: SmoTempoTextParams, index: number) {
+  addTempo(tempo: SmoTempoParams, index: number) {
     this.measures[index].setTempo(tempo);
   }
 

package/src/smo/midi/midiToSmo.ts

@@ -7,7 +7,7 @@
 import { SmoToMidi } from "./smoToMidi";
 import { Clef, Pitch } from "../data/common";
 import { SmoMeasure } from "../data/measure";
-import { SmoTempoText, TimeSignature } from "../data/measureModifiers";
+import { SmoTempo, SmoTimeSignature } from "../data/measureModifiers";
 import { SmoMusic } from "../data/music";
 import { SmoNote } from "../data/note";
 import { SmoScore } from "../data/score";
@@ -18,7 +18,7 @@ import {SmoTuplet, SmoTupletTree} from "../data/tuplet";
 import { SmoOperation } from "../xform/operations";
 
 export type MidiEventType = 'text' | 'copyrightNotice' | 'trackName' | 'instrumentName' | 'lyrics' | 'marker' |
-  'cuePoint' | 'channelPrefix' | 'portPrefix' | 'endOfTrack' | 'setTempo' | 'smpteOffset' | 'timeSignature' | 'keySignature' |
+  'cuePoint' | 'channelPrefix' | 'portPrefix' | 'endOfTrack' | 'setTempo' | 'smpteOffset' | 'SmoTimeSignature' | 'keySignature' |
   'sequencerSpecific' | 'unknownMeta' |
   'noteOff' | 'noteOn' | 'noteAftertouch' | 'controller' | 'programChange' | 'channelAftertouch' | 'pitchBend';
 
@@ -46,8 +46,8 @@ export interface MidiTrackEvent {
  */
 export interface RunningMetadata {
   keySignature: string,
-  timeSignature: TimeSignature,
-  tempo: SmoTempoText
+  timeSignature: SmoTimeSignature,
+  tempo: SmoTempo
 }
 /**
  * @category serialization
@@ -75,8 +75,8 @@ export interface EventSmoData {
   tupletInfo: MidiTupletInfo | null,
   isRest: boolean,
   isTied: boolean,
-  timeSignature: TimeSignature,
-  tempo: SmoTempoText,
+  timeSignature: SmoTimeSignature,
+  tempo: SmoTempo,
   keySignature: string,
   measure: number,
   tick: number
@@ -100,8 +100,8 @@ export function getValueForTick<T>(arg: Record<number, T>, tick: number) {
  * @category serialization
  */
 export class MidiToSmo {
-  timeSignatureMap: Record<number, TimeSignature> = {};
-  tempoMap: Record<number, SmoTempoText> = {};
+  SmoTimeSignatureMap: Record<number, SmoTimeSignature> = {};
+  tempoMap: Record<number, SmoTempo> = {};
   keySignatureMap: Record<number, string> = {};
   tieMap: Record<number, number[]> = {};
   timeDivision: number = 480;
@@ -153,8 +153,8 @@ export class MidiToSmo {
   constructor(midi: any, quantizeDuration: number) {
     this.midi = midi;
     // console.log(JSON.stringify(midi, null, ''));
-    this.timeSignatureMap[0] = new TimeSignature(TimeSignature.defaults);
-    this.tempoMap[0] = new SmoTempoText(SmoTempoText.defaults);
+    this.SmoTimeSignatureMap[0] = new SmoTimeSignature(SmoTimeSignature.defaults);
+    this.tempoMap[0] = new SmoTempo(SmoTempo.defaults);
     this.keySignatureMap[0] = 'c';
     this.timeDivision = midi.header.ticksPerBeat;
     this.quantizeTicks = quantizeDuration;
@@ -175,11 +175,11 @@ export class MidiToSmo {
    * @param ticks 
    * @returns 
    */
-  getTimeSignature(ticks: number): TimeSignature {
-    if (this.timeSignatureMap[ticks]) {
-      return this.timeSignatureMap[ticks];
+  getSmoTimeSignature(ticks: number): SmoTimeSignature {
+    if (this.SmoTimeSignatureMap[ticks]) {
+      return this.SmoTimeSignatureMap[ticks];
     }
-    return getValueForTick(this.timeSignatureMap, ticks);
+    return getValueForTick(this.SmoTimeSignatureMap, ticks);
   }
   /**
    * @internal
@@ -199,7 +199,7 @@ export class MidiToSmo {
    */
   getMetadata(ticks: number) {
     return { tempo: this.getTempo(ticks), 
-      timeSignature: this.getTimeSignature(ticks), keySignature: this.getKeySignature(ticks).toLowerCase() };
+      timeSignature: this.getSmoTimeSignature(ticks), keySignature: this.getKeySignature(ticks).toLowerCase() };
   }
   /**
    * We process 3 types of metadata at present:  time signature, tempo and keysignature.
@@ -209,22 +209,21 @@ export class MidiToSmo {
   handleMetadata(trackEvent: MidiTrackEvent, ticks: number) {
     if (trackEvent.meta) {
       const mtype = trackEvent.type;
-      if (mtype === 'timeSignature') {
+      if (mtype === 'SmoTimeSignature') {
         /**
          * whenever we get a time signature event, recompute ticks per measure
          */
         const numerator = trackEvent.numerator!;
         const denominator = trackEvent.denominator!;
-        const tsDef = TimeSignature.defaults;
-        tsDef.actualBeats = numerator;
-        tsDef.beatDuration = denominator;
-        const ts = new TimeSignature(tsDef);
-        this.timeSignatureMap[ticks] = ts;
+        const tsDef = SmoTimeSignature.defaults;
+        tsDef.times.push({actualBeats: numerator, beatDuration:denominator});
+        const ts = new SmoTimeSignature(tsDef);
+        this.SmoTimeSignatureMap[ticks] = ts;
       } else if (mtype === 'setTempo') {
         const bpm = 60 / (trackEvent.microsecondsPerBeat! / 1000000);
-        const tempoDef = SmoTempoText.defaults;
+        const tempoDef = SmoTempo.defaults;
         tempoDef.bpm = bpm;
-        this.tempoMap[ticks] = new SmoTempoText(tempoDef);
+        this.tempoMap[ticks] = new SmoTempo(tempoDef);
       } else if (mtype === 'keySignature') {
         const mdata = trackEvent.key!;
         if (mdata === 0) {
@@ -255,8 +254,8 @@ export class MidiToSmo {
    */
   createNewEvent(metadata: RunningMetadata): EventSmoData {
     return {
-      pitches: [], durationTicks: 0, tupletInfo: null, isRest: false, timeSignature: new TimeSignature(metadata.timeSignature),
-      tempo: new SmoTempoText(metadata.tempo), keySignature: metadata.keySignature, measure: 0, tick: 0, isTied: false
+      pitches: [], durationTicks: 0, tupletInfo: null, isRest: false, timeSignature: new SmoTimeSignature(metadata.timeSignature),
+      tempo: new SmoTempo(metadata.tempo), keySignature: metadata.keySignature, measure: 0, tick: 0, isTied: false
     };
   }
   /**
@@ -264,8 +263,8 @@ export class MidiToSmo {
    */
   static copyEvent(o: EventSmoData): EventSmoData {
     const pitches = JSON.parse(JSON.stringify(o.pitches));
-    const timeSignature = new TimeSignature(o.timeSignature);
-    const tempo = new SmoTempoText(o.tempo);
+    const timeSignature = new SmoTimeSignature(o.timeSignature);
+    const tempo = new SmoTempo(o.tempo);
     return ({
       pitches, durationTicks: o.durationTicks, tupletInfo: o.tupletInfo, isRest: o.isRest, timeSignature, tempo, keySignature: o.keySignature,
       measure: o.measure, tick: o.tick, isTied: o.isTied
@@ -298,8 +297,8 @@ export class MidiToSmo {
       if (measure === null || ev.measure > measureIndex) {
         const measureDefs = SmoMeasure.defaults;
         measureDefs.keySignature = ev.keySignature;
-        measureDefs.timeSignature = new TimeSignature(ev.timeSignature);
-        measureDefs.tempo = new SmoTempoText(ev.tempo);
+        measureDefs.timeSignature = new SmoTimeSignature(ev.timeSignature);
+        measureDefs.tempo = new SmoTempo(ev.tempo);
         measure = new SmoMeasure(measureDefs);
         measure.voices.push({ notes: [] });
         measureIndex = ev.measure;

package/src/smo/midi/smoToMidi.ts

@@ -5,7 +5,7 @@
  * @module /smo/midi/smoToMidi
  */
 import { SmoMusic } from '../data/music';
-import { TimeSignature, SmoTempoText } from '../data/measureModifiers';
+import { SmoTimeSignature, SmoTempo } from '../data/measureModifiers';
 import { ScoreRoadMapBuilder } from '../xform/roadmap';
 import { SmoScore } from '../data/score';
 import { PopulateAudioData } from '../xform/updateAudio';
@@ -67,8 +67,8 @@ import Writer from 'midi-writer-js';
 export interface MidiTrackHash {
   track: any,
   lastMeasure: number,
-  timeSignature?: TimeSignature,
-  tempo?: SmoTempoText,
+  timeSignature?: SmoTimeSignature,
+  tempo?: SmoTempo,
   keySignature?: string
 }
 function stavesToSkip(score: SmoScore): number[] {

package/src/smo/mxml/smoToXml.ts

@@ -6,7 +6,7 @@ import { SmoMusic } from '../data/music';
 import { SmoMeasure, SmoVoice } from '../data/measure';
 import { SmoSystemStaff } from '../data/systemStaff';
 import { SmoScore } from '../data/score';
-import { SmoBarline, TimeSignature, SmoRehearsalMark, SmoMeasureModifierBase } from '../data/measureModifiers';
+import { SmoBarline, SmoTimeSignature, SmoRehearsalMark, SmoMeasureModifierBase } from '../data/measureModifiers';
 import { SmoStaffHairpin, SmoSlur, SmoTie } from '../data/staffModifiers';
 import { SmoArticulation, SmoLyric, SmoOrnament } from '../data/noteModifiers';
 import { SmoSelector } from '../xform/selections';
@@ -14,7 +14,7 @@ import { SmoTuplet, SmoTupletTree } from '../data/tuplet';
 
 import { XmlHelpers } from './xmlHelpers';
 import { smoSerialize } from '../../common/serializationHelpers';
-import { SmoTempoText } from '../data/measureModifiers';
+import { SmoTempo } from '../data/measureModifiers';
 import { XmlToSmo } from './xmlToSmo';
 import { SmoSystemGroup } from '../data/scoreModifiers';
 import { SuiSampleMedia } from '../../render/audio/samples';
@@ -51,8 +51,8 @@ export interface SmoState {
   note?: SmoNote,
   beamState: number,
   beamTicks: number,
-  timeSignature?: TimeSignature,
-  tempo?: SmoTempoText,
+  timeSignature?: SmoTimeSignature,
+  tempo?: SmoTempo,
   currentTupletLevel: number, // not sure about the name
 }
 
@@ -637,13 +637,13 @@ export class SmoToXml {
     if (smoState.tempo) {
       if (tempo.display && measure.measureNumber.measureIndex === 0 && smoState.measureTicks === 0) {
         displayTempo = true;
-      } else if (tempo.display && !SmoTempoText.eq(smoState.tempo, tempo)) {
+      } else if (tempo.display && !SmoTempo.eq(smoState.tempo, tempo)) {
         displayTempo = true;
       }
     } else {
       displayTempo = true;
     }
-    smoState.tempo = new SmoTempoText(tempo);
+    smoState.tempo = new SmoTempo(tempo);
     if (beforeNote === true && smoState.staffPartIx === 0 && smoState.measureTicks === 0 && smoState.partStaves[0].staffId === 0) {
       const mark: SmoMeasureModifierBase | undefined = measure.getRehearsalMark();
       if (mark) {
@@ -661,12 +661,12 @@ export class SmoToXml {
       const tempoElement = nn(directionElement, 'direction-type', null, '');
       XmlHelpers.createAttribute(directionElement, 'placement', 'above');
       let tempoText = tempo.tempoText;
-      if (tempo.tempoMode === SmoTempoText.tempoModes.customMode) {
+      if (tempo.tempoMode === SmoTempo.tempoModes.customMode) {
         tempoText = tempo.customText;
       }
-      if (tempo.tempoMode === SmoTempoText.tempoModes.textMode) {
+      if (tempo.tempoMode === SmoTempo.tempoModes.textMode) {
         nn(tempoElement, 'words', { words: tempoText }, 'words');
-      } else if (tempo.tempoMode === SmoTempoText.tempoModes.customMode || tempo.tempoMode === SmoTempoText.tempoModes.durationMode) {
+      } else if (tempo.tempoMode === SmoTempo.tempoModes.customMode || tempo.tempoMode === SmoTempo.tempoModes.durationMode) {
         const metronomeElement = nn(tempoElement, 'metronome', null, '');
         let durationType = 'quarter';
         let dotType = false;
@@ -901,8 +901,8 @@ export class SmoToXml {
     const nn = XmlHelpers.createTextElementChild;
     const staff = smoState.partStaves[smoState.staffPartIx];
     const measure = staff.measures[smoState.measureIndex];
-    const currentTs = (smoState.timeSignature as TimeSignature) ?? null;
-    if (currentTs !== null && TimeSignature.equal(currentTs, measure.timeSignature)) {
+    const currentTs = (smoState.timeSignature as SmoTimeSignature) ?? null;
+    if (currentTs !== null && SmoTimeSignature.equal(currentTs, measure.timeSignature)) {
       return;
     }
     smoState.timeSignature = measure.timeSignature;

package/src/smo/mxml/xmlState.ts

@@ -13,7 +13,7 @@ import {
   SmoTie,
   TieLine
 } from '../data/staffModifiers';
-import {SmoBarline, SmoMeasureModifierBase, SmoRehearsalMark, SmoTempoText} from '../data/measureModifiers';
+import {SmoBarline, SmoMeasureModifierBase, SmoRehearsalMark, SmoTempo} from '../data/measureModifiers';
 import {SmoPartInfo} from '../data/partInfo';
 import {SmoMeasure} from '../data/measure';
 import {SmoNote} from '../data/note';
@@ -164,7 +164,7 @@ export interface XmlPartGroup {
 export class XmlState {
   static get defaults() {
     return {
-      divisions: 4096, tempo: new SmoTempoText(SmoTempoText.defaults), timeSignature: '4/4', keySignature: 'c',
+      divisions: 4096, tempo: new SmoTempo(SmoTempo.defaults), timeSignature: '4/4', keySignature: 'c',
       clefInfo: [], staffGroups: [], smoStaves: []
     };
   }
@@ -195,7 +195,7 @@ export class XmlState {
   tupletStatesInProgress: Record<number, XmlTupletState> = {};
 
   tickCursor: number = 0;
-  tempo: SmoTempoText = new SmoTempoText(SmoTempoText.defaults);
+  tempo: SmoTempo = new SmoTempo(SmoTempo.defaults);
   staffArray: XmlStaffInfo[] = [];
   staffIndex: number = 0;
   graceNotes: SmoGraceNote[] = [];

package/src/smo/mxml/xmlToSmo.ts

@@ -8,7 +8,7 @@ import { XmlHelpers } from './xmlHelpers';
 import { XmlVoiceInfo, XmlState, XmlWedgeInfo } from './xmlState';
 import { SmoLayoutManager, SmoPageLayout, SmoSystemGroup } from '../data/scoreModifiers';
 import { SmoTextGroup } from '../data/scoreText';
-import { SmoTempoText, SmoMeasureFormat, SmoMeasureModifierBase, SmoVolta, SmoBarline } from '../data/measureModifiers';
+import { SmoTempo, SmoMeasureFormat, SmoMeasureModifierBase, SmoVolta, SmoBarline } from '../data/measureModifiers';
 import { SmoScore, isEngravingFont } from '../data/score';
 import { SmoMeasure, SmoMeasureParams } from '../data/measure';
 import { SmoMusic } from '../data/music';
@@ -397,11 +397,11 @@ export class XmlToSmo {
   static tempo(element: Element) {
     let tempoText = '';
     let customText = tempoText;
-    const rv: { staffId: number, tempo: SmoTempoText }[] = [];
+    const rv: { staffId: number, tempo: SmoTempo }[] = [];
     const soundNodes = XmlHelpers.getChildrenFromPath(element,
       ['sound']);
     soundNodes.forEach((sound) => {
-      let tempoMode = SmoTempoText.tempoModes.durationMode;
+      let tempoMode = SmoTempo.tempoModes.durationMode;
       tempoText = sound.getAttribute('tempo') as string;
       if (tempoText) {
         const bpm = parseInt(tempoText, 10);
@@ -410,20 +410,20 @@ export class XmlToSmo {
         tempoText = wordNode.length ? wordNode[0].textContent as string :
           tempoText.toString();
         if (isNaN(parseInt(tempoText, 10))) {
-          if (SmoTempoText.tempoTexts[tempoText.toLowerCase()]) {
-            tempoMode = SmoTempoText.tempoModes.textMode;
+          if (SmoTempo.tempoTexts[tempoText.toLowerCase()]) {
+            tempoMode = SmoTempo.tempoModes.textMode;
           } else {
-            tempoMode = SmoTempoText.tempoModes.customMode;
+            tempoMode = SmoTempo.tempoModes.customMode;
             customText = tempoText;
           }
         }
-        const params = SmoTempoText.defaults;
+        const params = SmoTempo.defaults;
         params.tempoMode = tempoMode;
         params.bpm = bpm;
         params.tempoText = tempoText;
         params.customText = customText;
         params.display = true;
-        const tempo = new SmoTempoText(params);
+        const tempo = new SmoTempo(params);
         const staffId = XmlHelpers.getStaffId(element);
         rv.push({ staffId, tempo });
       }
@@ -567,7 +567,7 @@ export class XmlToSmo {
     // Only display tempo if changes.
     if (tempo.length) {
       // TODO: staff ID is with tempo, but tempo is per column in SMO
-      if (!SmoTempoText.eq(xmlState.tempo, tempo[0].tempo)) {
+      if (!SmoTempo.eq(xmlState.tempo, tempo[0].tempo)) {
         xmlState.tempo = tempo[0].tempo;
         xmlState.tempo.display = true;
       }

package/src/smo/xform/copypaste.ts

@@ -13,7 +13,7 @@ import { TickMap } from './tickMap';
 import { SmoSystemStaff } from '../data/systemStaff';
 import { getId, Clef, Pitch } from '../data/common';
 import {SmoUnmakeTupletActor} from "./tickDuration";
-import { SmoTempoText, TimeSignature } from '../data/measureModifiers';
+import { SmoTempo, SmoTimeSignature } from '../data/measureModifiers';
 
 /**
  * Used to calculate the offset and transposition of a note to be pasted
@@ -212,8 +212,8 @@ export class PasteBuffer {
     // 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 = measureSelection.measure.keySignature;
-    clonedMeasure.timeSignature = new TimeSignature(measureSelection.measure.timeSignature);
-    clonedMeasure.tempo = new SmoTempoText(measureSelection.measure.tempo);
+    clonedMeasure.timeSignature = new SmoTimeSignature(measureSelection.measure.timeSignature);
+    clonedMeasure.tempo = new SmoTempo(measureSelection.measure.tempo);
     this.measures.push(clonedMeasure);
 
     const firstMeasure = this.measures[0];

package/src/smo/xform/operations.ts

@@ -10,8 +10,8 @@ import { SmoArticulation, SmoGraceNote, SmoLyric, SmoMicrotone, SmoOrnament,
   SmoDynamicText, 
   SmoTabNote} from '../data/noteModifiers';
 import {
-  SmoRehearsalMark, SmoMeasureText, SmoVolta, SmoMeasureFormat, SmoTempoText, SmoBarline,
-  TimeSignature, SmoRepeatSymbol
+  SmoRehearsalMark, SmoMeasureText, SmoVolta, SmoMeasureFormat, SmoTempo, SmoBarline,
+  SmoTimeSignature, SmoRepeatSymbol
 } from '../data/measureModifiers';
 import { SmoStaffHairpin, SmoSlur, SmoTie, StaffModifierBase, SmoTieParams, SmoInstrument, SmoStaffHairpinParams,
   SmoSlurParams, SmoInstrumentMeasure, SmoStaffTextBracket, SmoStaffTextBracketParams,
@@ -139,7 +139,7 @@ export class SmoOperation {
       score.staves[tabStaves[0].startSelector.staff].removeTabStaves(tabStaves);
     }
   }
-  static setTimeSignature(score: SmoScore, selections: SmoSelection[], timeSignature: TimeSignature) {
+  static setTimeSignature(score: SmoScore, selections: SmoSelection[], timeSignature: SmoTimeSignature) {
     const selectors: SmoSelector[] = [];
     let i = 0;
     // change the time signature for each stave in the score
@@ -151,7 +151,7 @@ export class SmoOperation {
     });
     selectors.forEach((selector: SmoSelector) => {
       const rowSelection: SmoSelection = (SmoSelection.measureSelection(score, selector.staff, selector.measure) as SmoSelection);
-      rowSelection.measure.timeSignature = new TimeSignature(timeSignature);
+      rowSelection.measure.timeSignature = new SmoTimeSignature(timeSignature);
       rowSelection.measure.alignNotesWithTimeSignature();
     });
   }
@@ -744,7 +744,7 @@ export class SmoOperation {
     });
   }
 
-  static addTempo(score: SmoScore, selection: SmoSelection, tempo: SmoTempoText) {
+  static addTempo(score: SmoScore, selection: SmoSelection, tempo: SmoTempo) {
     score.staves.forEach((staff) => {
       staff.addTempo(tempo, selection.selector.measure);
     });
@@ -1050,7 +1050,10 @@ export class SmoOperation {
       }
     });
     selections[0].staff.measureInstrumentMap = instMap;
-    selections[0].staff.updateInstrumentOffsets();
+    // Don't update transpositions if everything is in concert key.
+    if (!score.preferences.transposingScore){
+      selections[0].staff.updateInstrumentOffsets();
+    }
     score.setNoteInstrumentProperties();
   }
   static computeMultipartRest(score: SmoScore) {

package/src/smo/xform/tickDuration.ts

@@ -277,8 +277,16 @@ export class SmoStretchNoteActor extends TickIteratorBase {
       stemTicksUsed: number,
       multiplier: number
   ) {
-    const remainingTicks = stemTicksUsed - this.newStemTicks;
-
+    const originalTickCount = this.notes.reduce((a, b) => a + b.tickCount, 0);
+    const measureTicks = this.measure.timeSignature.ticksFromTimeSignature() - 
+      (originalTickCount + (replacingNote.tickCount - originalNote.tickCount));
+    let remainingTicks = stemTicksUsed - this.newStemTicks;
+    // If this is the last note in the measure, and the measure doesn't have the full duration of notes,
+    // allow stretching.  This isn't something that can usually happen, 
+    // except in cases like import from xml, time signature changes, etc.
+    if (remainingTicks < 0 && measureTicks >= 0) {
+        remainingTicks = 0;
+    }
     if (remainingTicks >= 0) {
       this.notesToInsert.push(replacingNote);
 

package/src/ui/buttons/display.ts

@@ -1,7 +1,7 @@
 import { SuiButton, SuiButtonParams } from './button';
 import { createAndDisplayDialog } from '../dialogs/dialog';
 import { SuiKeySignatureDialog } from '../dialogs/keySignature';
-import { SuiTimeSignatureDialog } from '../dialogs/timeSignature';
+import { SuiTimeSignatureDialogVue } from '../dialogs/timeSignature';
 import { SuiTempoDialog } from '../dialogs/tempo';
 import { SuiScoreViewDialogVue } from '../dialogs/scoreView';
 import { KeyEvent } from '../../smo/data/common';
@@ -96,7 +96,7 @@ export class DisplaySettings extends SuiButton {
     if (!this.completeNotifier) {
       return;
     }
-    createAndDisplayDialog(SuiTimeSignatureDialog, {
+    SuiTimeSignatureDialogVue({
       completeNotifier: this.completeNotifier,
       view: this.view,
       eventSource: this.eventSource,

package/src/ui/buttons/ribbon.ts

@@ -19,7 +19,7 @@ import { createApp, ref, reactive, watch } from 'vue';
 import { SuiKeySignatureDialog } from '../dialogs/keySignature';
 import { default as ribbonApp } from '../components/buttons/ribbon.vue';
 import { default as ribbonSidebarApp } from '../components/buttons/sidebar.vue';
-import { SuiTimeSignatureDialog } from '../dialogs/timeSignature';
+import { SuiTimeSignatureDialogVue } from '../dialogs/timeSignature';
 import { SuiScoreViewDialogVue } from '../dialogs/scoreView';
 
 declare var $: any;
@@ -150,7 +150,7 @@ export class RibbonButtons {
       if (!this.controller) {
         return;
       }
-      createAndDisplayDialog(SuiTimeSignatureDialog, {
+      SuiTimeSignatureDialogVue({
         completeNotifier: this.controller,
         view: this.view,
         eventSource: this.eventSource,