smoosic 1.0.14 → 1.0.15

package/src/application/exports.ts

@@ -98,6 +98,7 @@ import { TextCheckComponent } from '../ui/dialogs/components/textCheck';
 import { SuiMenuManager} from '../ui/menus/manager';
 import { SuiMenuBase, SuiMenuCustomizer } from '../ui/menus/menu';
 import { SuiScoreMenu } from '../ui/menus/score';
+import { SuiEditMenu } from '../ui/menus/edit';
 import { SuiTextMenu } from '../ui/menus/text';
 import { SuiPartMenu } from '../ui/menus/parts';
 import { SuiVoiceMenu } from '../ui/menus/voices';
@@ -346,7 +347,7 @@ export const Smo = {
   // Menus
   SuiMenuManager, SuiMenuBase, SuiMenuCustomizer, SuiScoreMenu, SuiFileMenu,
   SuiDynamicsMenu, SuiTimeSignatureMenu, SuiKeySignatureMenu, SuiStaffModifierMenu,
-  SuiLanguageMenu, SuiMeasureMenu, SuiNoteMenu, SmoLanguage, SmoTranslator, SuiPartMenu,
+  SuiLanguageMenu, SuiMeasureMenu, SuiNoteMenu, SuiEditMenu, SmoLanguage, SmoTranslator, SuiPartMenu,
   SuiPartSelectionMenu, SuiTextMenu, SuiVoiceMenu, SuiBeamMenu,
   // Dialogs
   SuiGraceNoteAdapter, SuiGraceNoteDialog, SuiGraceNoteButtonsComponent,

package/src/common/vex.ts

@@ -86,6 +86,8 @@ export type TabNotePosition = VexTabNotePosition;
 // @internal
 export type TabNoteStruct = VexTabNoteStruct;
 
+const lineDefaults = [4, 2, 0, 1, 3];    // lines to turn off if there are less than 5
+
 /**
  * @internal
  */
@@ -163,6 +165,7 @@ export interface SmoVexStaveParams {
   canceledKey: string | null,
   startX: number,
   adjX: number,
+  lines: number,
   context: any
 }
 export function createTabStave(box: SvgBox, spacing: number, numLines: number): TabStave {
@@ -224,6 +227,14 @@ export function createStave(params: SmoVexStaveParams) {
         fill: 'none', 'stroke-width': 1, stroke: 'white'
     });
   }
+  if (params.lines < 5) {
+    const linesAr = [];
+    for (let i = 0; i < lineDefaults.length; ++i) {
+      const visible = lineDefaults[i] < params.lines;
+      linesAr.push({ visible });
+    }
+    stave.setConfigForLines(linesAr);
+  }
   // stave.options.spaceAboveStaffLn = 0; // don't let vex place the staff, we want to.
   stave.options.space_above_staff_ln = 0; // don't let vex place the staff, we want to.
   // Add a clef and time signature.

package/src/render/audio/samples.ts

@@ -382,14 +382,14 @@ export class SuiSampleMedia {
       sample: 'sample-asax-a3',
       family: 'wind',
       instrument: 'tenorSax',
-      nativeFrequency: SmoAudioPitch.smoPitchToFrequency({ letter: 'a', accidental: 'n', octave: 3 }, 24, null),
+      nativeFrequency: SmoAudioPitch.smoPitchToFrequency({ letter: 'a', accidental: 'n', octave: 3 }, 12, null),
     });
     SuiSampleMedia.insertIntoMap({
       sustain: 'sustained',
       sample: 'sample-asax-c4',
       family: 'wind',
       instrument: 'tenorSax',
-      nativeFrequency: SmoAudioPitch.smoPitchToFrequency({ letter: 'c', accidental: 'n', octave: 4 }, 24, null),
+      nativeFrequency: SmoAudioPitch.smoPitchToFrequency({ letter: 'c', accidental: 'n', octave: 4 }, 12, null),
     });
     SuiSampleMedia.insertIntoMap({
       sustain: 'sustained',

package/src/render/sui/mapper.ts

@@ -395,8 +395,10 @@ export abstract class SuiMapper {
     }
     return true;    
   }
-  // ### updateMeasure
-  // A measure has changed.  Update the music geometry for it
+
+  /**
+   * This is the logic that stores the screen location of music after it's rendered
+   */
   mapMeasure(staff: SmoSystemStaff, measure: SmoMeasure, printing: boolean) {
     let voiceIx = 0;
     let selectedTicks = 0;
@@ -433,8 +435,12 @@ export abstract class SuiMapper {
           tick,
           pitches: []
         };
-        if (typeof(note.logicalBox) === 'undefined') {
-          console.warn('note has no box');
+        if (measure.repeatSymbol) {
+          // Some measures have a symbol that replaces the notes.  This allows us to select
+          // the measure
+          const x = measure.svg.logicalBox.x + (measure.svg.logicalBox.width / voice.notes.length) * tick;
+          const width = measure.svg.logicalBox.width / voice.notes.length;
+          note.logicalBox = { x, y: measure.svg.logicalBox.y, width, height: measure.svg.logicalBox.height };
         }
         // create a selection for the newly rendered note
         const selection = new SmoSelection({

package/src/render/sui/scoreRender.ts

@@ -107,7 +107,11 @@ export class SuiScoreRender {
       // If this text is attached to the measure, base the block location on the rendered measure location.
       if (newGroup.attachToSelector) {
         // If this text is attached to a staff that is not visible, don't draw it.
-        const mappedStaff = this.score!.staves.find((staff) => staff.staffId === newGroup.selector!.staff);
+        let mappedStaff = this.score!.staves.find((staff) => staff.staffId === newGroup.selector!.staff);
+        if (this.score?.isPartExposed() && this.score.staves[0].partInfo.preserveTextGroups) {
+          mappedStaff = this.score!.staves.find((staff) => 
+            staff.getMappedStaffId() === newGroup.selector!.staff);
+        }
         if (!mappedStaff) {
           return;
         }

package/src/render/sui/scoreViewOperations.ts

@@ -1235,6 +1235,32 @@ export class SuiScoreViewOperations extends SuiScoreView {
     this.replaceMeasureView(measureRange);
     await this.renderer.updatePromise();
   }
+  /**
+   * Paste only the chords.
+   */
+  async pasteChords(): Promise<void> {
+        // We undo the whole score on a paste, since we don't yet know the
+    // extent of the overlap
+    this.renderer.preserveScroll();
+    const selections: SmoSelection[]  = this.getPasteMeasureList();
+    const firstSelection = selections[0];
+    const measureEnd = selections[selections.length - 1].selector.measure;
+    const measureRange = [firstSelection.selector.measure, measureEnd];
+    this.storeUndo.grouping = true;
+    // Undo the paste by selecting all the affected measures
+    for (let i = measureRange[0]; i <= measureRange[1]; ++i) {
+      this._undoColumn('paste', i);
+      this.renderer.unrenderColumn(this.score.staves[0].measures[i]);
+    }
+    this.storeUndo.grouping = false;
+    const altSelection = this._getEquivalentSelection(firstSelection);
+    const altTarget = altSelection!.selector;
+    altTarget.tick = this.tracker.selections[0].selector.tick;
+    this.storePaste.pasteChords(altTarget);
+    // Refresh those measures.
+    this.replaceMeasureView(measureRange);
+    await this.renderer.updatePromise();
+  }
   /**
    * specify a note head other than the default for the duration
    * @param head 

package/src/render/vex/vxMeasure.ts

@@ -505,6 +505,7 @@ export class VxMeasure implements VxMeasureIf {
       canceledKey,
       startX: this.smoMeasure.svg.maxColumnStartX,
       adjX: this.smoMeasure.svg.adjX,
+      lines: this.smoMeasure.lines,
       context: this.context.getContext()
     }
     this.stave = createStave(smoVexStaveParams);

package/src/smo/data/measure.ts

@@ -861,6 +861,7 @@ export class SmoMeasure implements SmoMeasureParams, TickMappable {
     // 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);
+    obj.lines = params.lines;
     // Don't redisplay tempo for a new measure
     const rv = new SmoMeasure(obj);
     if (rv.tempo && rv.tempo.display) {

package/src/smo/data/noteModifiers.ts

@@ -6,7 +6,8 @@
  * @module /smo/data/noteModifiers
  */
 import { SmoAttrs, Ticks, Pitch, getId, SmoObjectParams, Transposable, SvgBox, SmoModifierBase, 
-  Clef, IsClef, SmoDynamicCtor } from './common';
+  Clef, IsClef, SmoDynamicCtor, 
+  IsPitchLetter} from './common';
 import { smoSerialize } from '../../common/serializationHelpers';
 import { SmoMusic } from './music';
 import { defaultNoteScale, FontInfo, getChordSymbolGlyphFromCode } from '../../common/vex';
@@ -931,6 +932,46 @@ export class SmoLyric extends SmoNoteModifierBase {
       this.adjustNoteWidthChord = val;
     }
   }
+  static transposeChordToKey(chord: SmoLyric, offset: number, srcKey: string, destKey: string): SmoLyric {
+    if (chord.parser !== SmoLyric.parsers.chord || offset === 0) {
+      return new SmoLyric(chord);
+    }
+    const nchord = new SmoLyric(chord);
+    let srcIx = 0;
+    const maxLen = chord.text.length - 1;
+    let destString = '';
+    while (srcIx < chord.text.length) {
+      let symbolBlock = false;
+      const nchar = chord.text[srcIx];
+      let lk = srcIx < maxLen ? chord.text[srcIx + 1] : null;
+      // make sure this chord start witha VEX pitch letter (A-G upper case)
+      if (IsPitchLetter(nchar.toLowerCase()) && nchar == nchar.toUpperCase()) {
+        if (lk === '@') {
+          symbolBlock = true;
+          srcIx += 1;
+          lk = srcIx < maxLen ? chord.text[srcIx + 1] : null;
+        }
+        const pitch: Pitch = {letter: nchar.toLowerCase() as any, accidental: 'n', octave: 4 };
+        if (lk !== null && (lk === 'b' || lk === '#')) {
+          pitch.accidental = lk;
+          srcIx += 1;
+        }
+        const npitch = SmoMusic.transposePitchForKey(pitch, srcKey, destKey, offset);
+        destString += npitch.letter.toUpperCase();
+        if (symbolBlock) {
+          destString += '@';
+        }
+        if (npitch.accidental !== 'n') {
+          destString += npitch.accidental;
+        }
+      } else {
+        destString += nchar;
+      }
+      srcIx += 1;
+    }
+    nchord.text = destString;
+    return nchord;
+  }
 
   // ### getClassSelector
   // returns a selector used to find this text block within a note.

package/src/smo/data/score.ts

@@ -722,6 +722,12 @@ export class SmoScore {
     if (!isSmoScoreParams(params)) {
       throw 'Bad score, missing params: ' + JSON.stringify(params, null, ' ');
     }
+    if (params.staves.length === 1) {
+      const part = params.staves[0].partInfo;
+      if (part) {
+        part.expandMultimeasureRests = true;
+      }
+    }
     const score = new SmoScore(params);
     score.textGroups = textGroups;
     score.systemGroups = systemGroups;
@@ -950,8 +956,12 @@ export class SmoScore {
     // immediately preceeding or post-ceding measure if it exists.
     if (measureIndex < staff.measures.length) {
       protomeasure = staff.measures[measureIndex];
+      const instrument = staff.getStaffInstrument(measureIndex);
+      protomeasure.lines = instrument.lines;
     } else if (staff.measures.length) {
       protomeasure = staff.measures[staff.measures.length - 1];
+      const instrument = staff.getStaffInstrument(staff.measures.length - 1);
+      protomeasure.lines = instrument.lines;
     } else {
       protomeasure = SmoMeasure.defaults;
     }

package/src/smo/data/staffModifiers.ts

@@ -158,7 +158,8 @@ export interface SmoInstrumentParams {
   /**
    * future, can be used to set sample
    */
-  mutes?: string,  
+  mutes?: string,
+  lines: number
 }
 
 /**
@@ -174,8 +175,8 @@ export interface SmoInstrumentParamsSer extends SmoInstrumentParams {
 function isSmoInstrumentParamsSer(params: Partial<SmoInstrumentParamsSer>): params is SmoInstrumentParamsSer {
   return params?.ctor === 'SmoInstrument';
 }
-export type SmoInstrumentNumParamType = 'keyOffset' | 'midichannel' | 'midiport' | 'midiInstrument';
-export const SmoInstrumentNumParams: SmoInstrumentNumParamType[] = ['keyOffset', 'midichannel', 'midiport', 'midiInstrument'];
+export type SmoInstrumentNumParamType = 'keyOffset' | 'midichannel' | 'midiport' | 'midiInstrument' | 'lines';
+export const SmoInstrumentNumParams: SmoInstrumentNumParamType[] = ['keyOffset', 'midichannel', 'midiport', 'midiInstrument', 'lines'];
 export type SmoInstrumentStringParamType = 'instrumentName' | 'abbreviation' | 'family' | 'instrument';
 export const SmoInstrumentStringParams: SmoInstrumentStringParamType[] = ['instrumentName', 'abbreviation', 'family', 'instrument'];
 /**
@@ -187,7 +188,8 @@ export const SmoInstrumentStringParams: SmoInstrumentStringParamType[] = ['instr
  */
 export class SmoInstrument extends StaffModifierBase {
   static get attributes() {
-    return ['startSelector', 'endSelector', 'keyOffset', 'midichannel', 'midiport', 'instrumentName', 'abbreviation', 'instrument', 'family'];
+    return ['startSelector', 'endSelector', 
+      'keyOffset', 'midichannel', 'midiport', 'instrumentName', 'abbreviation', 'instrument', 'family', 'lines'];
   }
   startSelector: SmoSelector;
   endSelector: SmoSelector;
@@ -196,6 +198,7 @@ export class SmoInstrument extends StaffModifierBase {
   keyOffset: number = 0;
   clef: Clef = 'treble';
   midiInstrument: number = 1;
+  lines: number = 5;
   midichannel: number;
   midiport: number;
   family: string;
@@ -214,7 +217,8 @@ export class SmoInstrument extends StaffModifierBase {
       midiInstrument: 1,
       midiport: 0,
       startSelector: SmoSelector.default,
-      endSelector: SmoSelector.default
+      endSelector: SmoSelector.default,
+      lines: 5
     }));
   }
   static get defaultOscillatorParam(): SmoOscillatorInfo {
@@ -241,6 +245,11 @@ export class SmoInstrument extends StaffModifierBase {
     } else {
       name = (params as any).instrument;
     }
+    if (typeof ((params as any).lines) === 'undefined') {
+      this.lines = 5;
+    } else {
+      this.lines = params.lines;
+    }
     this.instrumentName = name;
     this.family = params.family;
     this.instrument = params.instrument;

package/src/smo/data/systemStaff.ts

@@ -380,6 +380,7 @@ export class SmoSystemStaff implements SmoObjectParams {
         curInstrumentIndex += 1;
       }
       measure.transposeIndex = instrumentAr[curInstrumentIndex].instrument.keyOffset;
+      measure.lines = instrumentAr[curInstrumentIndex].instrument.lines;
       params.measures.push(measure);
     });
     if (jsonObj.modifiers) {
@@ -416,6 +417,15 @@ export class SmoSystemStaff implements SmoObjectParams {
       }
       mod.associatedStaff = to; // this.staffId will remap to 'to' value
     });
+    this.textBrackets.forEach((mod: SmoStaffTextBracket) => {
+      if (mod.startSelector.staff === from) {
+        mod.startSelector.staff = to;
+      }
+      if (mod.endSelector.staff === from) {
+        mod.endSelector.staff = to;
+      }
+      mod.associatedStaff = to; // this.staffId will remap to 'to' value
+    });
   }
   updateMeasureFormatsForPart() {
     this.measures.forEach((measure, mix) => {
@@ -453,6 +463,7 @@ export class SmoSystemStaff implements SmoObjectParams {
         const tabStave: SmoTabStave | undefined = this.getTabStaveForMeasure(SmoSelector.fromMeasure(measure));
         measure.transposeToOffset(entry.instrument.keyOffset, targetKey, entry.instrument.clef);
         measure.transposeIndex = entry.instrument.keyOffset;
+        measure.lines = entry.instrument.lines;
         measure.keySignature = targetKey;
         measure.setClef(entry.instrument.clef);
       }

package/src/smo/xform/copypaste.ts

@@ -4,6 +4,7 @@ import { SmoSelection, SmoSelector } from './selections';
 import { SmoNote } from '../data/note';
 import { SmoMeasure, SmoVoice } from '../data/measure';
 import { StaffModifierBase } from '../data/staffModifiers';
+import { SmoLyric } from '../data/noteModifiers';
 import {SmoTuplet, SmoTupletTree, SmoTupletTreeParams} from '../data/tuplet';
 import { SmoMusic } from '../data/music';
 import { SvgHelpers } from '../../render/sui/svgHelpers';
@@ -131,6 +132,14 @@ export class PasteBuffer {
         const keyOffset = -1 * selection.measure.transposeIndex;
         const destKey = SmoMusic.vexKeySignatureTranspose(originalKey, keyOffset).toLocaleLowerCase();
         const note = SmoNote.transpose(SmoNote.clone(selection.note),[], keyOffset, selection.measure.keySignature, destKey) as SmoNote;
+        const chords: SmoLyric[] = note.getChords();
+        chords.forEach((chord) => {
+          note.removeLyric(chord);
+        });
+        chords.forEach((chord) => {
+          const nchord = SmoLyric.transposeChordToKey(chord, keyOffset, selection.measure.keySignature, destKey);
+          note.addLyric(nchord);
+        });
         const pasteNote: PasteNote = {
           selector,
           note,
@@ -517,7 +526,47 @@ export class PasteBuffer {
     }
     serializedMeasure.voices = voices;
   }
-
+  pasteChords(selector: SmoSelector) {
+    if (this.notes.length < 1) {
+      return;
+    }
+    if (!this.score) {
+      return;
+    }
+    let srcTick = 0;
+    let destTick = 0;
+    let srcIndex = 0;
+    let selection = SmoSelection.noteSelection(this.score!, selector.staff, selector.measure, selector.voice, selector.tick);   
+    while (selection && selection.note && srcIndex < this.notes.length) {
+      const srcNote = this.notes[srcIndex].note;
+      const chords = srcNote.getChords();
+      if (selection && selection.note) {
+        const destNote = selection.note;
+        if (chords.length) {
+          chords.forEach((chord) => {
+            destNote.removeLyric(chord);
+          });
+          chords.forEach((chord) => {
+            if (selection) {
+            const nchord = SmoLyric.transposeChordToKey(
+              chord, selection.measure.transposeIndex,this.notes[srcIndex].originalKey, selection.measure.keySignature);
+              destNote.addLyric(nchord);
+            }
+          });
+        }
+        srcTick += srcNote.tickCount;
+        while (selection && selection.note && destTick < srcTick) {
+          destTick += selection.note.tickCount;
+          if (selection && selection.note) {
+            const curSelector = selection.selector;
+            selection = SmoSelection.nextNoteSelection(this.score, 
+              curSelector.staff, curSelector.measure, curSelector.voice, curSelector.tick);
+          }
+        }
+        srcIndex += 1;
+      }
+    }
+  }
   pasteSelections(selector: SmoSelector) {
     let i = 0;
     if (this.notes.length < 1) {

package/src/smo/xform/operations.ts

@@ -87,11 +87,26 @@ export class SmoOperation {
       });
     });
   }
+  /**
+   * Move a single stave up or down one.  If last down, move to first.
+   * If first up, move to last
+   * @param score 
+   * @param selection 
+   * @param index 
+   */
   static moveStaffUpDown(score: SmoScore, selection: SmoSelection, index: number) {
     const index1 = selection.selector.staff;
     const index2 = selection.selector.staff + index;
     if (index2 < score.staves.length && index2 >= 0) {
       score.swapStaves(index1, index2);
+    } else if (index2 === score.staves.length) {
+      for (let i = 0; i < (score.staves.length - 1); ++i) {
+        score.swapStaves((score.staves.length - 1) - i, (score.staves.length - 1) - (i + 1));
+      }
+    } else if (index2 < 0) {
+      for (let i = 0; i < (score.staves.length - 1); ++i) {
+        score.swapStaves(i, i + 1);
+      }
     }
   }
 

package/src/ui/dialogs/instrument.ts

@@ -38,7 +38,12 @@ export class SuiInstrumentAdapter extends SuiComponentAdapter {
     this.view.changeInstrument(this.instrument, this.selections);
     this.instrument = new SmoInstrument(this.instrument);
   }
-
+  get lines() {
+    return this.instrument.lines;
+  }
+  set lines(value: number) {
+    this.writeNumParam('lines', value);
+  }
   get transposeIndex() {
     return this.instrument.keyOffset;
   }
@@ -108,6 +113,11 @@ export class SuiInstrumentDialog extends SuiDialogAdapterBase<SuiInstrumentAdapt
         label: 'Instrument Properties',
         elements:
           [{
+            smoName: 'lines',
+            defaultValue: 5,
+            control: 'SuiRockerComponent',
+            label: 'Staff lines (1-5)'
+          }, {
             smoName: 'transposeIndex',
             defaultValue: 0,
             control: 'SuiRockerComponent',

package/src/ui/keyBindings/default/trackerKeys.ts

@@ -45,7 +45,7 @@ export class defaultTrackerKeys {
         ctrlKey: false,
         altKey: false,
         shiftKey: true,
-        action: "moveHome"
+        action: "moveEnd"
       }, {
         event: "keydown",
         key: "End",

package/src/ui/menus/edit.ts

@@ -0,0 +1,79 @@
+import { SuiMenuBase, SuiMenuParams, SuiConfiguredMenuOption, SuiConfiguredMenu } from './menu';
+
+declare var $: any;
+/**
+ * Stuff you can do to notes
+ * @category SuiMenu
+ */
+export class SuiEditMenu extends SuiConfiguredMenu {
+  constructor(params: SuiMenuParams) {
+    super(params, 'Edit', SuiEditMenuOptions);
+  }  
+}
+/**
+ * Copy Ctrl^C action
+ * @category SuiMenu
+ */
+const copyMenuOption: SuiConfiguredMenuOption = {
+  handler: async (menu: SuiMenuBase) => {
+    await menu.view.copy();
+  }, display: (menu: SuiMenuBase) => true,
+  menuChoice: {
+    icon: 'icon-copy',
+    text: 'Copy',
+    value: 'copyAction'
+  }
+}
+
+/**
+ * Copy Ctrl^C action
+ * @category SuiMenu
+ */
+const pasteMenuOption: SuiConfiguredMenuOption = {
+  handler: async (menu: SuiMenuBase) => {
+    await menu.view.paste();
+  }, display: (menu: SuiMenuBase) => true,
+  menuChoice: {
+    icon: 'icon-paste',
+    text: 'Paste',
+    value: 'pasteAction'
+  }
+}
+
+/**
+ * Copy Ctrl^C action
+ * @category SuiMenu
+ */
+const pasteChordsMenuOption: SuiConfiguredMenuOption = {
+  handler: async (menu: SuiMenuBase) => {
+    await menu.view.pasteChords();
+  }, display: (menu: SuiMenuBase) => true,
+  menuChoice: {
+    icon: '',
+    text: 'Paste Chords',
+    value: 'pasteChordsAction'
+  }
+}
+
+/**
+ * Copy Ctrl^C action
+ * @category SuiMenu
+ */
+const undoMenuOption: SuiConfiguredMenuOption = {
+  handler: async (menu: SuiMenuBase) => {
+    await menu.view.undo();
+  }, display: (menu: SuiMenuBase) => true,
+  menuChoice: {
+    icon: 'icon-undo',
+    text: 'Undo',
+    value: 'undoAction'
+  }
+}
+
+/**
+ * Note menu.  Stuff you can do to notes.
+ * @category SuiMenu
+ */
+const SuiEditMenuOptions: SuiConfiguredMenuOption[] = [
+  copyMenuOption, pasteMenuOption, pasteChordsMenuOption, undoMenuOption
+];

package/src/ui/menus/manager.ts

@@ -24,6 +24,7 @@ import { SuiStaffModifierMenu } from './staffModifier';
 import { SuiMeasureMenu } from './measure';
 import { SuiVoiceMenu } from './voices';
 import { SuiNoteMenu } from './note';
+import { SuiEditMenu } from './edit';
 import { SuiTextMenu } from './text';
 import { SuiPartSelectionMenu } from './partSelection';
 import { SuiPartMenu } from './parts';
@@ -275,6 +276,8 @@ export class SuiMenuManager {
       this.displayMenu(new SuiLanguageMenu(params));
     } else if (action === 'SuiFileMenu') {
       this.displayMenu(new SuiFileMenu(params));
+    } else if (action === 'SuiEditMenu') {
+      this.displayMenu(new SuiEditMenu(params));
     } else if (action === 'SuiScoreMenu') {
       this.displayMenu(new SuiScoreMenu(params));
     } else if (action === 'SuiPartSelectionMenu') {

package/src/ui/ribbonLayout/default/defaultRibbon.ts

@@ -23,7 +23,7 @@ export class defaultRibbonLayout {
   }
 
   static get leftRibbonIds() {
-    return ['helpDialog', 'languageMenu', 'fileMenu', 
+    return ['helpDialog', 'languageMenu', 'fileMenu', 'editMenu',
     'scoreMenu', 'partMenu', 'staffModifierMenu', 'measureModal', 'voiceMenu', 'beamMenu',
     'tupletMenu', 'noteMenu', 'textMenu', 'libraryMenu',
     ];
@@ -174,11 +174,21 @@ export class defaultRibbonLayout {
       ctor: 'SuiLanguageMenu',
       group: 'scoreEdit',
       id: 'languageMenu'
+    }, {
+      leftText: 'Edit',
+      rightText: 'Alt-e',
+      hotKey: 'e',
+      icon: '',
+      classes: 'file-modify nav-link link-body-emphasis hover-text',
+      action: 'menu',
+      ctor: 'SuiEditMenu',
+      group: 'scoreEdit',
+      id: 'editMenu'
     }, {
       leftText: 'File',
       rightText: 'Alt-f',
       hotKey: 'f',
-      icon: '',
+      icon: 'icon-clipboard',
       classes: 'file-modify nav-link link-body-emphasis hover-text',
       action: 'menu',
       ctor: 'SuiFileMenu',