first time signature simplifications

Author: mscuthbert

src/fonts/bravura_metrics.ts

@@ -242,7 +242,7 @@ export const BravuraMetrics = {
 
   // These are for numeric digits, such as in time signatures
   digits: {
-    // used by timesig
+    // used by TimeSignature object
     shiftLine: -1,
     point: 34,
 

src/fonts/leland_metrics.ts

@@ -237,7 +237,7 @@ export const LelandMetrics = {
 
   // These are for numeric digits, such as in time signatures
   digits: {
-    // used by timesig
+    // used by TimeSignature objects
     shiftLine: -1,
     point: 34,
 

src/note.ts

@@ -488,7 +488,7 @@ export abstract class Note extends Tickable {
 
   /** Accessor to isDotted. */
   isDotted(): boolean {
-    return this.getModifiersByType('Dot').length > 0;
+    return this.getModifiersByType(Category.Dot).length > 0;
   }
 
   /** Accessor to hasStem. */

src/timesignature.ts

@@ -14,7 +14,7 @@ import { defined, RuntimeError } from './util';
 
 export interface TimeSignatureInfo {
   glyph: Glyph;
-  line?: number;
+  line: number;
   num: boolean;
 }
 
@@ -60,13 +60,21 @@ export class TimeSignature extends StaveModifier {
   bottomLine: number;
   topLine: number;
 
-  protected info: TimeSignatureInfo;
+  protected line: number = 0;
+  protected glyph: Glyph;
+  protected is_numeric: boolean = true;
   protected validate_args: boolean;
 
   constructor(timeSpec: string = '4/4', customPadding = 15, validate_args = true) {
     super();
     this.validate_args = validate_args;
 
+    // violates DRY w/ setTimeSig(timeSpec) but needed to convince TypeScript that all is well.
+    const info = this.parseTimeSpec(timeSpec);
+    this.glyph = info.glyph;
+    this.is_numeric = info.num;
+    this.line = info.line;
+
     const padding = customPadding;
 
     const musicFont = Tables.currentMusicFont();
@@ -75,8 +83,7 @@ export class TimeSignature extends StaveModifier {
     this.topLine = 2 + fontLineShift;
     this.bottomLine = 4 + fontLineShift;
     this.setPosition(StaveModifierPosition.BEGIN);
-    this.info = this.parseTimeSpec(timeSpec);
-    this.setWidth(defined(this.info.glyph.getMetrics().width));
+    this.setWidth(defined(this.glyph.getMetrics().width));
     this.setPadding(padding);
   }
 
@@ -97,6 +104,7 @@ export class TimeSignature extends StaveModifier {
     const parts = timeSpec.split('/');
 
     return {
+      line: 0,
       num: true,
       glyph: this.makeTimeSignatureGlyph(parts[0] ?? '', parts[1] ?? ''),
     };
@@ -106,26 +114,60 @@ export class TimeSignature extends StaveModifier {
     return new TimeSignatureGlyph(this, topDigits, botDigits, 'timeSig0', this.point);
   }
 
+  /**
+   * Returns line, num, glyph -- but these can be accessed directly w/ getters and setters.
+   */
   getInfo(): TimeSignatureInfo {
-    return this.info;
+    const { line, is_numeric, glyph } = this;
+    return { line, num: is_numeric, glyph };
   }
 
+  /**
+   * Set a new time signature specification without changing customPadding, etc.
+   */
   setTimeSig(timeSpec: string): this {
-    this.info = this.parseTimeSpec(timeSpec);
+    const info = this.parseTimeSpec(timeSpec);
+    this.glyph = info.glyph;
+    this.is_numeric = info.num;
+    this.line = info.line;
     return this;
   }
 
+  getLine(): number {
+    return this.line;
+  }
+
+  setLine(line: number) {
+    this.line = line;
+  }
+
+  getGlyph(): Glyph {
+    return this.glyph;
+  }
+
+  setGlyph(glyph: Glyph) {
+    this.glyph = glyph;
+  }
+
+  getIsNumeric(): boolean {
+    return this.is_numeric;
+  }
+
+  setIsNumeric(isNumeric: boolean) {
+    this.is_numeric = isNumeric;
+  }
+
   draw(): void {
     const stave = this.checkStave();
     const ctx = stave.checkContext();
     this.setRendered();
 
     this.applyStyle(ctx);
     ctx.openGroup('timesignature', this.getAttribute('id'));
-    this.info.glyph.setStave(stave);
-    this.info.glyph.setContext(ctx);
-    this.placeGlyphOnLine(this.info.glyph, stave, this.info.line);
-    this.info.glyph.renderToStave(this.x);
+    this.glyph.setStave(stave);
+    this.glyph.setContext(ctx);
+    this.placeGlyphOnLine(this.glyph, stave, this.line);
+    this.glyph.renderToStave(this.x);
     ctx.closeGroup();
     this.restoreStyle(ctx);
   }

src/timesignote.ts

@@ -3,22 +3,21 @@
 
 import { ModifierContext } from './modifiercontext';
 import { Note } from './note';
-import { TimeSignature, TimeSignatureInfo } from './timesignature';
+import { TimeSignature } from './timesignature';
 import { Category } from './typeguard';
 
 export class TimeSigNote extends Note {
   static get CATEGORY(): string {
     return Category.TimeSigNote;
   }
 
-  protected timeSigInfo: TimeSignatureInfo;
+  protected timeSig: TimeSignature;
 
   constructor(timeSpec: string, customPadding?: number) {
     super({ duration: 'b' });
 
-    const timeSignature = new TimeSignature(timeSpec, customPadding);
-    this.timeSigInfo = timeSignature.getInfo();
-    this.setWidth(this.timeSigInfo.glyph.getMetrics().width);
+    this.timeSig = new TimeSignature(timeSpec, customPadding);
+    this.setWidth(this.timeSig.getGlyph().getMetrics().width);
 
     // Note properties
     this.ignore_ticks = true;
@@ -41,12 +40,13 @@ export class TimeSigNote extends Note {
     const ctx = this.checkContext();
     this.setRendered();
 
-    if (!this.timeSigInfo.glyph.getContext()) {
-      this.timeSigInfo.glyph.setContext(ctx);
+    const tsGlyph = this.timeSig.getGlyph();
+    if (!tsGlyph.getContext()) {
+      tsGlyph.setContext(ctx);
     }
 
-    this.timeSigInfo.glyph.setStave(stave);
-    this.timeSigInfo.glyph.setYShift(stave.getYForLine(2) - stave.getYForGlyphs());
-    this.timeSigInfo.glyph.renderToStave(this.getAbsoluteX());
+    tsGlyph.setStave(stave);
+    tsGlyph.setYShift(stave.getYForLine(2) - stave.getYForGlyphs());
+    tsGlyph.renderToStave(this.getAbsoluteX());
   }
 }

tests/timesignature_tests.ts

@@ -38,6 +38,13 @@ function parser(): void {
   const mustPass = ['4/4', '10/12', '1/8', '1234567890/1234567890', 'C', 'C|', '+'];
   mustPass.forEach((validString) => timeSig.parseTimeSpec(validString));
 
+  timeSig.parseTimeSpec('4/4');
+  equal(timeSig.getIsNumeric(), true, '4/4 is numeric');
+  equal(timeSig.getLine(), 0, 'digits are on line 0');
+  timeSig.parseTimeSpec('C|');
+  equal(timeSig.getIsNumeric(), false, 'cut time is not numeric');
+  equal(timeSig.getLine(), 2, 'cut/common are on line 2');
+
   ok(true, 'all pass');
 }