Add Guitar Pro 7 Exporter

.gitignore

@@ -8,4 +8,5 @@ bin/
 .vs/
 *.user
 *.tgz
-test-results/
+test-results/
+debug.log

karma.conf.js

@@ -74,6 +74,19 @@ module.exports = function (config) {
                         });
                     }
                 );
+                app.post(
+                    '/save-file',
+                    upload.fields([
+                        {
+                            name: 'file',
+                            maxCount: 1
+                        }
+                    ]),
+                    function (req, res) {
+                        log.info(`save file ${req.file}`);
+                        res.send(JSON.stringify('OK'));
+                    }
+                );
                 app.post(
                     '/save-visual-error',
                     upload.fields([
@@ -95,6 +108,27 @@ module.exports = function (config) {
                         res.send(JSON.stringify('OK'));
                     }
                 );
+                app.post(
+                    '/list-files',
+                    upload.fields([
+                        {
+                            name: 'expected',
+                            maxCount: 1
+                        },
+                        {
+                            name: 'actual',
+                            maxCount: 1
+                        },
+                        {
+                            name: 'diff',
+                            maxCount: 1
+                        }
+                    ]),
+                    function (req, res) {
+                        log.info(`save visual error ${req.file}`);
+                        res.send(JSON.stringify('OK'));
+                    }
+                );
             }
         },
 

playground-template/control-template.html

@@ -100,6 +100,9 @@
                 <a href="#" class="at-print" data-toggle="tooltip" data-placement="top" title="Print">
                     <i class="fas fa-print"></i>
                 </a>
+                <a href="#" class="at-download" data-toggle="tooltip" data-placement="top" title="Download">
+                    <i class="fas fa-download"></i>
+                </a>                
 
                 <div class="btn-group dropup">
                     <button

playground-template/control.js

@@ -235,6 +235,17 @@ function setupControl(selector) {
         at.print();
     };
 
+    control.querySelector('.at-download').onclick = function (e) {
+        const exporter = new alphaTab.exporter.Gp7Exporter();
+        const data = exporter.export(at.score, at.settings);
+        const a = document.createElement('a');
+        a.download = at.score.title.length > 0 ? at.score.title + '.gp' : 'song.gp';
+        a.href = URL.createObjectURL(new Blob([data]));
+        document.body.appendChild(a);
+        a.click();
+        document.body.removeChild(a);
+    };
+
     control.querySelectorAll('.at-zoom-options a').forEach(function (a) {
         a.onclick = function (e) {
             e.preventDefault();

src.compiler/csharp/CSharpAstPrinter.ts

@@ -857,24 +857,29 @@ export default class CSharpAstPrinter {
     }
 
     private writeStringTemplateExpression(expr: cs.StringTemplateExpression) {
-        this.write('$@"');
+        this.write('string.Format(System.Globalization.CultureInfo.InvariantCulture, @"');
+        let exprs: cs.Expression[] = [];
         expr.chunks.forEach(c => {
             if (c.nodeType === cs.SyntaxKind.StringLiteral) {
                 const escapedText = (c as cs.StringLiteral).text
                     .split('"')
                     .join('""')
-                    .split('{')
-                    .join('{{')
-                    .split('}')
-                    .join('}}');
+                    .split('\n')
+                    .join('\\n')
+                    .split('\r')
+                    .join('\\r');
                 this.write(escapedText);
             } else {
-                this.write('{');
-                this.writeExpression(c as cs.Expression);
-                this.write('}');
+                this.write(`{${exprs.length}}`);
+                exprs.push(c as cs.Expression);
             }
         });
         this.write('"');
+        exprs.forEach(expr => {
+            this.write(', ');
+            this.writeExpression(expr);
+        })
+        this.write(')');
     }
 
     private writeIsExpression(expr: cs.IsExpression) {

src.compiler/csharp/CSharpAstTransformer.ts

@@ -309,7 +309,7 @@ export default class CSharpAstTransformer {
             const text = node.getSourceFile().text;
             // check for /*@target web*/ marker
             const commentText = text.substr(node.getStart() - node.getLeadingTriviaWidth(), node.getLeadingTriviaWidth());
-            if(commentText.indexOf('/*@target web*/') >= 0) {
+            if (commentText.indexOf('/*@target web*/') >= 0) {
                 return true;
             }
         }
@@ -1228,6 +1228,15 @@ export default class CSharpAstTransformer {
             csMethod.body = this.visitBlock(csMethod, classElement.body);
         }
 
+        switch (csMethod.name) {
+            case 'ToString':
+                if (csMethod.parameters.length === 0) {
+                    csMethod.isVirtual = false;
+                    csMethod.isOverride = true;
+                }
+                break;
+        }
+
         parent.members.push(csMethod);
 
         this._context.registerSymbol(csMethod);
@@ -1982,6 +1991,10 @@ export default class CSharpAstTransformer {
             return null;
         }
 
+        if (csExpr.operator === "~") {
+            csExpr.operand = this.makeInt(csExpr.operand);
+        }
+
         return csExpr;
     }
 
@@ -2285,8 +2298,10 @@ export default class CSharpAstTransformer {
                 switch (expression.operatorToken.kind) {
                     case ts.SyntaxKind.AmpersandToken:
                     case ts.SyntaxKind.GreaterThanGreaterThanToken:
+                    case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
                     case ts.SyntaxKind.LessThanLessThanToken:
                     case ts.SyntaxKind.BarToken:
+                    case ts.SyntaxKind.CaretToken:
                         binaryExpression.left = this.makeInt(binaryExpression.left);
                         binaryExpression.right = this.makeInt(binaryExpression.right);
                         break;
@@ -2631,6 +2646,25 @@ export default class CSharpAstTransformer {
                 }
             });
 
+            return csExpr;
+        } else if (this.isSetInitializer(expression)) {
+            const csExpr = {
+                parent: parent,
+                tsNode: expression,
+                nodeType: cs.SyntaxKind.InvocationExpression,
+                arguments: [],
+                expression: {} as cs.Expression
+            } as cs.InvocationExpression;
+
+            csExpr.expression = this.makeMemberAccess(csExpr, 'AlphaTab.Core.TypeHelper', 'SetInitializer');
+
+            expression.elements.forEach(e => {
+                const ex = this.visitExpression(csExpr, e);
+                if (ex) {
+                    csExpr.arguments.push(ex);
+                }
+            });
+
             return csExpr;
         } else {
             const csExpr = {
@@ -2672,6 +2706,15 @@ export default class CSharpAstTransformer {
         return false;
     }
 
+    private isSetInitializer(expression: ts.ArrayLiteralExpression) {
+        const isCandidate = expression.parent.kind === ts.SyntaxKind.NewExpression;
+        if (!isCandidate) {
+            return false;
+        }
+
+        return this._context.typeChecker.getTypeAtLocation(expression.parent).symbol.name === 'Set';
+    }
+
     private visitPropertyAccessExpression(parent: cs.Node, expression: ts.PropertyAccessExpression) {
         const memberAccess = {
             expression: {} as cs.Expression,
@@ -2699,11 +2742,24 @@ export default class CSharpAstTransformer {
                             case 'length':
                                 memberAccess.member = 'Count';
                                 break;
+                            case 'reverse':
+                                memberAccess.member = 'Reversed';
+                                break;
                             case 'push':
                                 memberAccess.member = 'Add';
                                 break;
                         }
                         break;
+                    case 'String':
+                        switch (memberAccess.tsSymbol!.name) {
+                            case 'trimRight':
+                                memberAccess.member = 'TrimEnd';
+                                break;
+                            case 'trimLeft':
+                                memberAccess.member = 'TrimStart';
+                                break;
+                        }
+                        break;
                 }
             }
         }
@@ -2799,8 +2855,8 @@ export default class CSharpAstTransformer {
 
     private visitElementAccessExpression(parent: cs.Node, expression: ts.ElementAccessExpression) {
         // Enum[value] => value.ToString()
-        const symbol = this._context.typeChecker.getSymbolAtLocation(expression.expression);
-        if (symbol && symbol.flags & ts.SymbolFlags.Enum) {
+        const enumType = this._context.typeChecker.getTypeAtLocation(expression.expression);
+        if (enumType?.symbol && enumType.symbol.flags & ts.SymbolFlags.RegularEnum) {
             const callExpr = {
                 parent: parent,
                 arguments: [],
@@ -2843,6 +2899,7 @@ export default class CSharpAstTransformer {
             return null;
         }
 
+        const symbol = this._context.typeChecker.getSymbolAtLocation(expression.expression);
         let type = symbol ? this._context.typeChecker.getTypeOfSymbolAtLocation(symbol!, expression.expression) : null;
         if (type) {
             type = this._context.typeChecker.getNonNullableType(type);
@@ -2905,6 +2962,31 @@ export default class CSharpAstTransformer {
             }
         });
 
+        // number.ToString
+        const isNumberToString = ts.isPropertyAccessExpression(expression.expression)
+            && this._context.typeChecker.getTypeAtLocation(expression.expression.expression).flags & ts.TypeFlags.Number
+            && (expression.expression.name as ts.Identifier).text === 'toString'
+            && expression.arguments.length === 0;
+
+        if (isNumberToString) {
+            const invariantCultureInfo = {
+                parent: parent,
+                nodeType: cs.SyntaxKind.MemberAccessExpression,
+                tsNode: expression,
+                expression: null!,
+                member: 'InvariantCulture'
+            } as cs.MemberAccessExpression;
+
+            invariantCultureInfo.expression = {
+                parent: invariantCultureInfo,
+                tsNode: expression.expression,
+                nodeType: cs.SyntaxKind.Identifier,
+                text: 'System.Globalization.CultureInfo'
+            } as cs.Identifier;
+
+            callExpression.arguments.push(invariantCultureInfo);
+        }
+
         if (expression.typeArguments) {
             callExpression.typeArguments = [];
             expression.typeArguments.forEach(a =>
@@ -3216,9 +3298,8 @@ export default class CSharpAstTransformer {
             case ts.SyntaxKind.LessThanLessThanToken:
                 return '<<';
             case ts.SyntaxKind.GreaterThanGreaterThanToken:
-                return '>>';
             case ts.SyntaxKind.GreaterThanGreaterThanGreaterThanToken:
-                return '>>>';
+                return '>>';
 
             case ts.SyntaxKind.LessThanToken:
                 return '<';

src.compiler/csharp/CSharpEmitterContext.ts

@@ -613,7 +613,7 @@ export default class CSharpEmitterContext {
         }
 
         // object -> object
-        if(tsType.flags === ts.TypeFlags.NonPrimitive && 'objectFlags' in tsType && 'intrinsicName' in tsType) {
+        if (tsType.flags === ts.TypeFlags.NonPrimitive && 'objectFlags' in tsType && 'intrinsicName' in tsType) {
             const unknown = handleNullablePrimitive(cs.PrimitiveType.Object);
             unknown.isNullable = true;
             return unknown;
@@ -933,6 +933,12 @@ export default class CSharpEmitterContext {
             return null;
         }
 
+        // For Enum[value] we do not smart cast value to a number
+        if (ts.isElementAccessExpression(expression.parent) &&
+            expression.parent.argumentExpression === expression) {
+            return null;
+        }
+
         // we consider the expression as smart casted if the declared symbol has a different
         // contextual type than the declared type.
         let symbol = this.typeChecker.getSymbolAtLocation(expression);

src.csharp/AlphaTab.Test/Test/Globals.cs

@@ -42,6 +42,18 @@ public void ToEqual(object expected, string message = null)
             Assert.AreEqual(expected, _actual, _message + message);
         }
 
+        public void ToBeCloseTo(double expected, string message = null)
+        {
+            if (_actual is IConvertible c)
+            {
+                Assert.AreEqual(expected, c.ToDouble(System.Globalization.CultureInfo.InvariantCulture), 0.001, _message + message);
+            }
+            else
+            {
+                Assert.Fail("ToBeCloseTo can only be used with numeric operands");
+            }
+        }
+
         public void ToBe(object expected)
         {
             if (expected is int i && _actual is double)

src.csharp/AlphaTab.Test/TestPlatform.cs

@@ -16,9 +16,17 @@ public static async Task<Uint8Array> LoadFile(string path)
             return new Uint8Array(ms.ToArray());
         }
 
+        public static async Task SaveFile(string name, Uint8Array data)
+        {
+            var path = Path.Combine("test-results", name);
+            Directory.CreateDirectory(Path.GetDirectoryName(path));
+            await using var fs = new FileStream(Path.Combine("test-results", name), FileMode.Create);
+            await fs.WriteAsync(data.Data.Array!, data.Data.Offset, data.Data.Count);
+        }
+
         public static Task<IList<string>> ListDirectory(string path)
         {
-            return Task.FromResult((IList<string>)Directory.EnumerateFiles(path)
+            return Task.FromResult((IList<string>) Directory.EnumerateFiles(path)
                 .Select(Path.GetFileName)
                 .ToList());
         }

src.csharp/AlphaTab/Core/Dom/TextEncoder.cs

@@ -0,0 +1,20 @@
+using System.Text;
+using AlphaTab.Core.EcmaScript;
+
+namespace AlphaTab.Core.Dom
+{
+    internal class TextEncoder
+    {
+        private readonly Encoding _encoding;
+
+        public TextEncoder()
+        {
+            _encoding = Encoding.UTF8;
+        }
+
+        public Uint8Array Encode(string value)
+        {
+            return _encoding.GetBytes(value);
+        }
+    }
+}