feat: Different key signatures across staves

src.compiler/csharp/CSharpAstPrinter.ts

@@ -864,7 +864,7 @@ export default class CSharpAstPrinter extends AstPrinterBase {
 
     protected writeNonNullExpression(expr: cs.NonNullExpression) {
         this.writeExpression(expr.expression);
-        if (!cs.isNonNullExpression(expr)) {
+        if (!cs.isNonNullExpression(expr.expression)) {
             this.write('!');
         }
     }

src.compiler/csharp/CSharpAstTransformer.ts

@@ -3217,11 +3217,18 @@ export default class CSharpAstTransformer {
 
             csExpr.type = this._context.makeArrayTupleType(csExpr, []);
 
-            const tupleType = this._context.typeChecker.getContextualType(expression) ?? type;
+            let tupleType = this._context.typeChecker.getContextualType(expression);
+            let typeArgs = tupleType
+                ? this._context.typeChecker.getTypeArguments(tupleType as ts.TypeReference)
+                : undefined;
+            if (!typeArgs || typeArgs.length !== expression.elements.length) {
+                tupleType = type;
+                typeArgs = this._context.typeChecker.getTypeArguments(tupleType as ts.TypeReference);
+            }
 
-            (csExpr.type as cs.ArrayTupleNode).types = this._context.typeChecker
-                .getTypeArguments(tupleType as ts.TypeReference)
-                .map((p, i) => this.createUnresolvedTypeNode(csExpr.type, expression.elements[i], p));
+            (csExpr.type as cs.ArrayTupleNode).types = typeArgs!.map((p, i) =>
+                this.createUnresolvedTypeNode(csExpr.type, expression.elements[i], p)
+            );
 
             for (const e of expression.elements) {
                 const ex = this.visitExpression(csExpr, e);

src.compiler/csharp/CSharpEmitterContext.ts

@@ -656,7 +656,10 @@ export default class CSharpEmitterContext {
                         }
                     }
                     break;
+                case cs.SyntaxKind.ArrayTupleNode:
+                    return true;
             }
+
         }
         return false;
     }
@@ -1759,7 +1762,7 @@ export default class CSharpEmitterContext {
             return true;
         }
 
-        return this.isEnum(tsType);
+        return this.isEnum(tsType) || this.typeChecker.isTupleType(tsType);
     }
 
     public isEnum(tsType: ts.Type) {

src.compiler/kotlin/KotlinEmitterContext.ts

@@ -69,6 +69,13 @@ export default class KotlinEmitterContext extends CSharpEmitterContext {
         return undefined;
     }
 
+    protected isCsValueType(mapValueType: cs.TypeNode | null): boolean {
+        if(mapValueType?.nodeType === cs.SyntaxKind.ArrayTupleNode) {
+            return false;
+        }
+        return super.isCsValueType(mapValueType);
+    }
+
     public override getMethodNameFromSymbol(symbol: ts.Symbol): string {
         const parent = 'parent' in symbol ? (symbol.parent as ts.Symbol) : undefined;
 

src/generated/model/BarSerializer.ts

@@ -14,6 +14,8 @@ import { Voice } from "@src/model/Voice";
 import { SimileMark } from "@src/model/SimileMark";
 import { SustainPedalMarker } from "@src/model/Bar";
 import { BarLineStyle } from "@src/model/Bar";
+import { KeySignature } from "@src/model/KeySignature";
+import { KeySignatureType } from "@src/model/KeySignatureType";
 import { BarStyle } from "@src/model/Bar";
 export class BarSerializer {
     public static fromJson(obj: Bar, m: unknown): void {
@@ -37,6 +39,8 @@ export class BarSerializer {
         o.set("sustainpedals", obj.sustainPedals.map(i => SustainPedalMarkerSerializer.toJson(i)));
         o.set("barlineleft", obj.barLineLeft as number);
         o.set("barlineright", obj.barLineRight as number);
+        o.set("keysignature", obj.keySignature as number);
+        o.set("keysignaturetype", obj.keySignatureType as number);
         if (obj.style) {
             o.set("style", BarStyleSerializer.toJson(obj.style));
         }
@@ -84,6 +88,12 @@ export class BarSerializer {
             case "barlineright":
                 obj.barLineRight = JsonHelper.parseEnum<BarLineStyle>(v, BarLineStyle)!;
                 return true;
+            case "keysignature":
+                obj.keySignature = JsonHelper.parseEnum<KeySignature>(v, KeySignature)!;
+                return true;
+            case "keysignaturetype":
+                obj.keySignatureType = JsonHelper.parseEnum<KeySignatureType>(v, KeySignatureType)!;
+                return true;
             case "style":
                 if (v) {
                     obj.style = new BarStyle();

src/generated/model/MasterBarSerializer.ts

@@ -8,8 +8,6 @@ import { JsonHelper } from "@src/io/JsonHelper";
 import { SectionSerializer } from "@src/generated/model/SectionSerializer";
 import { AutomationSerializer } from "@src/generated/model/AutomationSerializer";
 import { FermataSerializer } from "@src/generated/model/FermataSerializer";
-import { KeySignature } from "@src/model/KeySignature";
-import { KeySignatureType } from "@src/model/KeySignatureType";
 import { TripletFeel } from "@src/model/TripletFeel";
 import { Section } from "@src/model/Section";
 import { Automation } from "@src/model/Automation";
@@ -28,8 +26,6 @@ export class MasterBarSerializer {
         }
         const o = new Map<string, unknown>();
         o.set("alternateendings", obj.alternateEndings);
-        o.set("keysignature", obj.keySignature as number);
-        o.set("keysignaturetype", obj.keySignatureType as number);
         o.set("isdoublebar", obj.isDoubleBar);
         o.set("isrepeatstart", obj.isRepeatStart);
         o.set("repeatcount", obj.repeatCount);
@@ -67,12 +63,6 @@ export class MasterBarSerializer {
             case "alternateendings":
                 obj.alternateEndings = v! as number;
                 return true;
-            case "keysignature":
-                obj.keySignature = JsonHelper.parseEnum<KeySignature>(v, KeySignature)!;
-                return true;
-            case "keysignaturetype":
-                obj.keySignatureType = JsonHelper.parseEnum<KeySignatureType>(v, KeySignatureType)!;
-                return true;
             case "isdoublebar":
                 obj.isDoubleBar = v! as boolean;
                 return true;

src/importer/AlphaTexImporter.ts

@@ -1674,8 +1674,6 @@ export class AlphaTexImporter extends ScoreImporter {
             const master: MasterBar = new MasterBar();
             this._score.addMasterBar(master);
             if (master.index > 0) {
-                master.keySignature = master.previousMasterBar!.keySignature;
-                master.keySignatureType = master.previousMasterBar!.keySignatureType;
                 master.timeSignatureDenominator = master.previousMasterBar!.timeSignatureDenominator;
                 master.timeSignatureNumerator = master.previousMasterBar!.timeSignatureNumerator;
                 master.tripletFeel = master.previousMasterBar!.tripletFeel;
@@ -1797,6 +1795,8 @@ export class AlphaTexImporter extends ScoreImporter {
         if (newBar.previousBar) {
             newBar.clef = newBar.previousBar.clef;
             newBar.clefOttava = newBar.previousBar.clefOttava;
+            newBar.keySignature = newBar.previousBar!.keySignature;
+            newBar.keySignatureType = newBar.previousBar!.keySignatureType;
         }
         this._barIndex++;
 
@@ -3014,8 +3014,8 @@ export class AlphaTexImporter extends ScoreImporter {
                 if (this._sy !== AlphaTexSymbols.String) {
                     this.error('keysignature', AlphaTexSymbols.String, true);
                 }
-                master.keySignature = this.parseKeySignature(this._syData as string);
-                master.keySignatureType = this.parseKeySignatureType(this._syData as string);
+                bar.keySignature = this.parseKeySignature(this._syData as string);
+                bar.keySignatureType = this.parseKeySignatureType(this._syData as string);
                 this._sy = this.newSy();
             } else if (syData === 'clef') {
                 this._sy = this.newSy();

src/importer/CapellaParser.ts

@@ -510,6 +510,9 @@ export class CapellaParser {
         if (staff.bars.length > 0) {
             currentBar.clef = staff.bars[staff.bars.length - 1].clef;
             currentBar.clefOttava = staff.bars[staff.bars.length - 1].clefOttava;
+            currentBar.keySignature = staff.bars[staff.bars.length - 1].keySignature;
+            currentBar.keySignatureType = staff.bars[staff.bars.length - 1].keySignatureType;
+
         } else {
             currentBar.clef = this._currentStaffLayout.defaultClef;
         }
@@ -520,8 +523,6 @@ export class CapellaParser {
             const master: MasterBar = new MasterBar();
             this.score.addMasterBar(master);
             if (master.index > 0) {
-                master.keySignature = master.previousMasterBar!.keySignature;
-                master.keySignatureType = master.previousMasterBar!.keySignatureType;
                 master.tripletFeel = master.previousMasterBar!.tripletFeel;
             }
 
@@ -611,7 +612,7 @@ export class CapellaParser {
                         this._currentBar.clefOttava = this.parseClefOttava(c.getAttribute('clef'));
                         break;
                     case 'keySign':
-                        this._currentBar.masterBar.keySignature = Number.parseInt(
+                        this._currentBar.keySignature = Number.parseInt(
                             c.getAttribute('fifths')
                         ) as KeySignature;
                         break;

src/importer/Gp3To5Importer.ts

@@ -59,7 +59,10 @@ export class Gp3To5Importer extends ScoreImporter {
     private _trackCount: number = 0;
     private _playbackInfos: PlaybackInformation[] = [];
     private _doubleBars: Set<number> = new Set<number>();
-
+    private _keySignatures: Map<number, [KeySignature, KeySignatureType]> = new Map<
+        number,
+        [KeySignature, KeySignatureType]
+    >();
     private _beatTextChunksByTrack: Map<number, string[]> = new Map<number, string[]>();
 
     private _directionLookup: Map<number, Direction[]> = new Map<number, Direction[]>();
@@ -367,11 +370,10 @@ export class Gp3To5Importer extends ScoreImporter {
         }
         // keysignature
         if ((flags & 0x40) !== 0) {
-            newMasterBar.keySignature = IOHelper.readSInt8(this.data) as KeySignature;
-            newMasterBar.keySignatureType = this.data.readByte() as KeySignatureType;
-        } else if (previousMasterBar) {
-            newMasterBar.keySignature = previousMasterBar.keySignature;
-            newMasterBar.keySignatureType = previousMasterBar.keySignatureType;
+            this._keySignatures.set(this._score.masterBars.length, [
+                IOHelper.readSInt8(this.data) as KeySignature,
+                this.data.readByte() as KeySignatureType
+            ]);
         }
         if (this._versionNumber >= 500 && (flags & 0x03) !== 0) {
             this.data.skip(4);
@@ -521,6 +523,15 @@ export class Gp3To5Importer extends ScoreImporter {
         }
         mainStaff.addBar(newBar);
 
+        if (this._keySignatures.has(newBar.index)) {
+            const newKeySignature = this._keySignatures.get(newBar.index)!;
+            newBar.keySignature = newKeySignature[0];
+            newBar.keySignatureType = newKeySignature[1];
+        } else if (newBar.index > 0) {
+            newBar.keySignature = newBar.previousBar!.keySignature;
+            newBar.keySignatureType = newBar.previousBar!.keySignatureType;
+        }
+
         if (this._doubleBars.has(newBar.index)) {
             newBar.barLineRight = BarLineStyle.LightLight;
         }

src/importer/GpifParser.ts

@@ -15,7 +15,7 @@ import { Fermata, FermataType } from '@src/model/Fermata';
 import { Fingers } from '@src/model/Fingers';
 import { GraceType } from '@src/model/GraceType';
 import { HarmonicType } from '@src/model/HarmonicType';
-import type { KeySignature } from '@src/model/KeySignature';
+import { KeySignature } from '@src/model/KeySignature';
 import { KeySignatureType } from '@src/model/KeySignatureType';
 import { Lyrics } from '@src/model/Lyrics';
 import { MasterBar } from '@src/model/MasterBar';
@@ -120,6 +120,10 @@ export class GpifParser {
     private _skipApplyLyrics: boolean = false;
 
     private _doubleBars: Set<MasterBar> = new Set<MasterBar>();
+    private _keySignatures: Map<number, [KeySignature, KeySignatureType]> = new Map<
+        number,
+        [KeySignature, KeySignatureType]
+    >();
 
     public parseXml(xml: string, settings: Settings): void {
         this._masterTrackAutomations = new Map<number, Automation[]>();
@@ -1203,20 +1207,23 @@ export class GpifParser {
                     }
                     break;
                 case 'Key':
-                    masterBar.keySignature = Number.parseInt(
+                    const keySignature = Number.parseInt(
                         c.findChildElement('AccidentalCount')!.innerText
                     ) as KeySignature;
                     const mode: XmlNode = c.findChildElement('Mode')!;
+                    let keySignatureType = KeySignatureType.Major;
                     if (mode) {
                         switch (mode.innerText.toLowerCase()) {
                             case 'major':
-                                masterBar.keySignatureType = KeySignatureType.Major;
+                                keySignatureType = KeySignatureType.Major;
                                 break;
                             case 'minor':
-                                masterBar.keySignatureType = KeySignatureType.Minor;
+                                keySignatureType = KeySignatureType.Minor;
                                 break;
                         }
                     }
+
+                    this._keySignatures.set(this._masterBars.length, [keySignature, keySignatureType]);
                     break;
                 case 'Fermatas':
                     this.parseFermatas(masterBar, c);
@@ -2413,9 +2420,12 @@ export class GpifParser {
             this.score.addTrack(track);
         }
         // process all masterbars
+        let keySignature: [KeySignature, KeySignatureType];
+
         for (const barIds of this._barsOfMasterBar) {
             // add all bars of masterbar vertically to all tracks
             let staffIndex: number = 0;
+            keySignature = [KeySignature.C, KeySignatureType.Major];
             for (
                 let barIndex: number = 0, trackIndex: number = 0;
                 barIndex < barIds.length && trackIndex < this.score.tracks.length;
@@ -2428,6 +2438,14 @@ export class GpifParser {
                     const staff: Staff = track.staves[staffIndex];
                     staff.addBar(bar);
 
+                    const masterBarIndex = staff.bars.length - 1;
+                    if (this._keySignatures.has(masterBarIndex)) {
+                        keySignature = this._keySignatures.get(masterBarIndex)!;
+                    }
+
+                    bar.keySignature = keySignature[0];
+                    bar.keySignatureType = keySignature[1];
+
                     if (this._doubleBars.has(bar.masterBar)) {
                         bar.barLineRight = BarLineStyle.LightLight;
                     }
@@ -2490,8 +2508,10 @@ export class GpifParser {
                     if (staffIndex === track.staves.length - 1) {
                         trackIndex++;
                         staffIndex = 0;
+                        keySignature = [KeySignature.C, KeySignatureType.Major];
                     } else {
                         staffIndex++;
+                        keySignature = [KeySignature.C, KeySignatureType.Major];
                     }
                 } else {
                     // no bar for track