feat(tab): add H/P text labels to hammer-on and pull-off arcs

In the Tab renderer, the arc connecting hammer-on and pull-off notes
is now annotated with an "H" (ascending fret = hammer-on) or "P"
(descending fret = pull-off) label above the arc midpoint.

The label is drawn via an overridden paint() in TabSlurGlyph, reusing
the same canvas.fillText path already used for whammy/bend slurText.
TieGlyph's coordinate fields (_startX/Y, _endX/Y, _tieHeight,
_shouldPaint) are widened from private to protected to allow the
subclass to read them during paint.

Fixes #2608

Author: rafaelsales

packages/alphatab/src/rendering/glyphs/TabBeatContainerGlyph.ts

@@ -66,12 +66,17 @@ export class TabBeatContainerGlyph extends BeatContainerGlyph {
                 }
             }
             if (!expanded) {
+                let slurText: string | undefined = undefined;
+                if (n.isHammerPullOrigin && n.hammerPullDestination) {
+                    slurText = n.hammerPullDestination.fret >= n.fret ? 'H' : 'P';
+                }
                 const effectSlur: TabSlurGlyph = new TabSlurGlyph(
                     `tab.slur.effect.${n.id}`,
                     n,
                     n.effectSlurDestination,
                     false,
-                    false
+                    false,
+                    slurText
                 );
                 this._effectSlurs.push(effectSlur);
                 this.addTie(effectSlur);

packages/alphatab/src/rendering/glyphs/TabSlurGlyph.ts

@@ -1,4 +1,5 @@
 import type { Note } from '@coderline/alphatab/model/Note';
+import type { ICanvas } from '@coderline/alphatab/platform/ICanvas';
 import { TabTieGlyph } from '@coderline/alphatab/rendering/glyphs/TabTieGlyph';
 import { BeamDirection } from '@coderline/alphatab/rendering/utils/BeamDirection';
 
@@ -7,16 +8,32 @@ import { BeamDirection } from '@coderline/alphatab/rendering/utils/BeamDirection
  */
 export class TabSlurGlyph extends TabTieGlyph {
     private _forSlide: boolean;
+    private readonly _slurText?: string;
 
-    public constructor(slurEffectId: string, startNote: Note, endNote: Note, forSlide: boolean, forEnd:boolean) {
+    public constructor(slurEffectId: string, startNote: Note, endNote: Note, forSlide: boolean, forEnd:boolean, slurText?: string) {
         super(slurEffectId, startNote, endNote, forEnd);
         this._forSlide = forSlide;
+        this._slurText = slurText;
     }
 
     public override getTieHeight(startX: number, _startY: number, endX: number, _endY: number): number {
         return (Math.log(endX - startX + 1) * this.renderer.settings.notation.slurHeight) / 2;
     }
 
+    public override paint(cx: number, cy: number, canvas: ICanvas): void {
+        super.paint(cx, cy, canvas);
+        if (this._slurText && this._shouldPaint) {
+            const midX = cx + (this._startX + this._endX) / 2;
+            const midY = cy + (this._startY + this._endY) / 2;
+            const apexOffset = this._tieHeight * 0.75;
+            const isDown = this.tieDirection === BeamDirection.Down;
+            const apexY = midY + (isDown ? apexOffset : -apexOffset);
+            const w = canvas.measureText(this._slurText).width;
+            const textY = isDown ? apexY : apexY - canvas.font.size;
+            canvas.fillText(this._slurText, midX - w / 2, textY);
+        }
+    }
+
     public tryExpand(startNote: Note, endNote: Note, forSlide: boolean, forEnd: boolean): boolean {
         // same type required
         if (this._forSlide !== forSlide) {

packages/alphatab/src/rendering/glyphs/TieGlyph.ts

@@ -31,13 +31,13 @@ export abstract class TieGlyph extends Glyph implements ITieGlyph {
         this.isForEnd = forEnd;
     }
 
-    private _startX: number = 0;
-    private _startY: number = 0;
-    private _endX: number = 0;
-    private _endY: number = 0;
-    private _tieHeight: number = 0;
+    protected _startX: number = 0;
+    protected _startY: number = 0;
+    protected _endX: number = 0;
+    protected _endY: number = 0;
+    protected _tieHeight: number = 0;
     private _boundingBox?: Bounds;
-    private _shouldPaint: boolean = false;
+    protected _shouldPaint: boolean = false;
 
     public get checkForOverflow() {
         return this._shouldPaint && this._boundingBox !== undefined;