Exemple #1
0
 public static void __hx_ctor_alphatab_model_Score(global::alphatab.model.Score __temp_me84)
 {
     unchecked
     {
         __temp_me84.masterBars          = new global::haxe.root.Array <object>();
         __temp_me84.tracks              = new global::haxe.root.Array <object>();
         __temp_me84._currentRepeatGroup = new global::alphatab.model.RepeatGroup();
     }
 }
        public static global::alphatab.model.Score loadScoreFromBytes(global::haxe.io.Bytes data)
        {
            unchecked
            {
                global::haxe.root.Array <object> importers = global::alphatab.importer.ScoreImporter.availableImporters();
                global::alphatab.model.Score     score     = default(global::alphatab.model.Score);
                {
                    int _g = 0;
                    while ((_g < importers.length))
                    {
                        global::alphatab.importer.ScoreImporter importer = ((global::alphatab.importer.ScoreImporter)(importers[_g]));
                        ++_g;
                        try
                        {
                            global::haxe.io.BytesInput input = new global::haxe.io.BytesInput(((global::haxe.io.Bytes)(data)), ((global::haxe.lang.Null <int>)(default(global::haxe.lang.Null <int>))), ((global::haxe.lang.Null <int>)(default(global::haxe.lang.Null <int>))));
                            importer.init(input);
                            score = importer.readScore();
                            break;
                        }
                        catch (global::System.Exception __temp_catchallException508)
                        {
                            object __temp_catchall509 = __temp_catchallException508;
                            if ((__temp_catchall509 is global::haxe.lang.HaxeException))
                            {
                                __temp_catchall509 = ((global::haxe.lang.HaxeException)(__temp_catchallException508)).obj;
                            }

                            {
                                object e = __temp_catchall509;
                                if (global::haxe.lang.Runtime.eq(e, global::alphatab.importer.ScoreImporter.UnsupportedFormat))
                                {
                                    continue;
                                }
                                else
                                {
                                    throw global::haxe.lang.HaxeException.wrap(e);
                                }
                            }
                        }
                    }
                }

                if ((score != default(global::alphatab.model.Score)))
                {
                    return(score);
                }
                else
                {
                    throw global::haxe.lang.HaxeException.wrap("No reader for the requested file found");
                }
            }
        }
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 188579043:
					{
						this.settings = ((global::alphatab.Settings) (@value) );
						return @value;
					}
					
					
					case 307761913:
					{
						this.renderingResources = ((global::alphatab.rendering.RenderingResources) (@value) );
						return @value;
					}
					
					
					case 1488498346:
					{
						this.layout = ((global::alphatab.rendering.layout.ScoreLayout) (@value) );
						return @value;
					}
					
					
					case 223048071:
					{
						this._currentLayoutMode = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 371166859:
					{
						this.track = ((global::alphatab.model.Track) (@value) );
						return @value;
					}
					
					
					case 2027516754:
					{
						this.score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					case 943871192:
					{
						this.canvas = ((global::alphatab.platform.ICanvas) (@value) );
						return @value;
					}
					
					
					case 1842287352:
					{
						this._renderFinishedListeners = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Exemple #4
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 67859554:
                {
                    this.start = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 2027516754:
                {
                    this.score = ((global::alphatab.model.Score)(@value));
                    return(@value);
                }


                case 726713937:
                {
                    this.volumeAutomation = ((global::alphatab.model.Automation)(@value));
                    return(@value);
                }


                case 288700050:
                {
                    this.tempoAutomation = ((global::alphatab.model.Automation)(@value));
                    return(@value);
                }


                case 1574438373:
                {
                    this.section = ((global::alphatab.model.Section)(@value));
                    return(@value);
                }


                case 1999551132:
                {
                    this.tripletFeel = ((global::alphatab.model.TripletFeel)(@value));
                    return(@value);
                }


                case 1324324830:
                {
                    this.timeSignatureNumerator = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 46594619:
                {
                    this.timeSignatureDenominator = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 1796997604:
                {
                    this.repeatGroup = ((global::alphatab.model.RepeatGroup)(@value));
                    return(@value);
                }


                case 462066548:
                {
                    this.repeatCount = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 1582764861:
                {
                    this.isRepeatStart = ((bool)(@value));
                    return(@value);
                }


                case 875656696:
                {
                    this.isDoubleBar = ((bool)(@value));
                    return(@value);
                }


                case 1832144217:
                {
                    this.keySignature = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 1041537810:
                {
                    this.index = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 127983386:
                {
                    this.previousMasterBar = ((global::alphatab.model.MasterBar)(@value));
                    return(@value);
                }


                case 344334046:
                {
                    this.nextMasterBar = ((global::alphatab.model.MasterBar)(@value));
                    return(@value);
                }


                case 1116545170:
                {
                    this.alternateEndings = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
Exemple #5
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 1085707415:
                {
                    this.chords = ((global::haxe.ds.StringMap <object>)(global::haxe.ds.StringMap <object> .__hx_cast <object>(((global::haxe.ds.StringMap)(@value)))));
                    return(@value);
                }


                case 1091626816:
                {
                    this.bars = ((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(@value)))));
                    return(@value);
                }


                case 2027516754:
                {
                    this.score = ((global::alphatab.model.Score)(@value));
                    return(@value);
                }


                case 73353859:
                {
                    this.isPercussion = ((bool)(@value));
                    return(@value);
                }


                case 983703593:
                {
                    this.playbackInfo = ((global::alphatab.model.PlaybackInformation)(@value));
                    return(@value);
                }


                case 1247572323:
                {
                    this.color = ((global::alphatab.platform.model.Color)(@value));
                    return(@value);
                }


                case 695082016:
                {
                    this.tuningName = global::haxe.lang.Runtime.toString(@value);
                    return(@value);
                }


                case 139280181:
                {
                    this.tuning = ((global::haxe.root.Array <int>)(global::haxe.root.Array <object> .__hx_cast <int>(((global::haxe.root.Array)(@value)))));
                    return(@value);
                }


                case 432148711:
                {
                    this.shortName = global::haxe.lang.Runtime.toString(@value);
                    return(@value);
                }


                case 1224700491:
                {
                    this.name = global::haxe.lang.Runtime.toString(@value);
                    return(@value);
                }


                case 1041537810:
                {
                    this.index = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                case 1102715933:
                {
                    this.capo = ((int)(global::haxe.lang.Runtime.toInt(@value)));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
		public virtual   void parseDom(global::haxe.root.Xml xml)
		{
			unchecked 
			{
				if (( xml.nodeType == global::haxe.root.Xml.Document )) 
				{
					xml = xml.firstElement();
				}
				
				if (string.Equals(xml._get_nodeName(), "GPIF")) 
				{
					this.score = new global::alphatab.model.Score();
					{
						object __temp_iterator416 = xml.iterator();
						while (((bool) (global::haxe.lang.Runtime.callField(__temp_iterator416, "hasNext", 407283053, default(global::haxe.root.Array))) ))
						{
							global::haxe.root.Xml n = ((global::haxe.root.Xml) (global::haxe.lang.Runtime.callField(__temp_iterator416, "next", 1224901875, default(global::haxe.root.Array))) );
							if (( n.nodeType == global::haxe.root.Xml.Element )) 
							{
								string _g = n._get_nodeName();
								switch (_g)
								{
									case "Score":
									{
										this.parseScoreNode(n);
										break;
									}
									
									
									case "MasterTrack":
									{
										this.parseMasterTrackNode(n);
										break;
									}
									
									
									case "Tracks":
									{
										this.parseTracksNode(n);
										break;
									}
									
									
									case "MasterBars":
									{
										this.parseMasterBarsNode(n);
										break;
									}
									
									
									case "Bars":
									{
										this.parseBars(n);
										break;
									}
									
									
									case "Voices":
									{
										this.parseVoices(n);
										break;
									}
									
									
									case "Beats":
									{
										this.parseBeats(n);
										break;
									}
									
									
									case "Notes":
									{
										this.parseNotes(n);
										break;
									}
									
									
									case "Rhythms":
									{
										this.parseRhythms(n);
										break;
									}
									
									
								}
								
							}
							
						}
						
					}
					
				}
				 else 
				{
					throw global::haxe.lang.HaxeException.wrap(global::alphatab.importer.ScoreImporter.UnsupportedFormat);
				}
				
				this.buildModel();
			}
		}
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 223988822:
					{
						this._tappedNotes = ((global::haxe.ds.StringMap<bool>) (global::haxe.ds.StringMap<object>.__hx_cast<bool>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 2001890127:
					{
						this._notesOfBeat = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 401348099:
					{
						this._noteById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 169770535:
					{
						this._rhythmById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1408430471:
					{
						this._beatById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1790892546:
					{
						this._rhythmOfBeat = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1952851773:
					{
						this._beatsOfVoice = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1524598821:
					{
						this._voiceById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1940366524:
					{
						this._voicesOfBar = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1715971153:
					{
						this._barsById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1395480923:
					{
						this._barsOfMasterBar = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1522424353:
					{
						this._masterBars = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1341358681:
					{
						this._tracksById = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1077438631:
					{
						this._tracksMapping = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 202704573:
					{
						this._automations = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 2027516754:
					{
						this.score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		public override   global::alphatab.model.Score readScore()
		{
			unchecked 
			{
				this.readVersion();
				this._score = new global::alphatab.model.Score();
				this.readScoreInformation();
				if (( this._versionNumber < 500 )) 
				{
					if (( this._data.readByte() != 0 )) 
					{
						this._globalTripletFeel = global::alphatab.model.TripletFeel.Triplet8th;
					}
					 else 
					{
						this._globalTripletFeel = global::alphatab.model.TripletFeel.NoTripletFeel;
					}
					
				}
				
				if (( this._versionNumber >= 400 )) 
				{
					this.readLyrics();
				}
				
				if (( this._versionNumber >= 510 )) 
				{
					this._data.read(19);
				}
				
				if (( this._versionNumber >= 500 )) 
				{
					this.readPageSetup();
					this._score.tempoLabel = this.readStringIntByte();
				}
				
				this._score.tempo = this.readInt32();
				if (( this._versionNumber >= 510 )) 
				{
					bool __temp_expr501 = ( this._data.readByte() != 0 );
				}
				
				this._keySignature = this.readInt32();
				if (( this._versionNumber >= 400 )) 
				{
					this._octave = this._data.readByte();
				}
				
				this.readPlaybackInfos();
				if (( this._versionNumber >= 500 )) 
				{
					this._data.read(38);
					this._data.read(4);
				}
				
				this._barCount = this.readInt32();
				this._trackCount = this.readInt32();
				this.readMasterBars();
				this.readTracks();
				this.readBars();
				this.finish(this._score);
				return this._score;
			}
		}
        public virtual int paintScoreInfo(int x, int y)
        {
            unchecked
            {
                int flags = default(int);
                if (this.renderer.settings.layout.@get <bool>("hideInfo", false))
                {
                    flags = 0;
                }
                else
                {
                    flags = 511;
                }

                global::alphatab.model.Score score = this.renderer._get_score();
                double scale = this.renderer.settings.scale;
                global::alphatab.platform.ICanvas             canvas = this.renderer.canvas;
                global::alphatab.rendering.RenderingResources res    = this.renderer.renderingResources;
                canvas.setColor(new global::alphatab.platform.model.Color(((int)(0)), ((int)(0)), ((int)(0)), ((global::haxe.lang.Null <int>)(default(global::haxe.lang.Null <int>)))));
                canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Center);
                double tX   = default(double);
                double size = default(double);
                string str  = "";
                if ((!(this.isNullOrEmpty(score.title)) && (((flags & 1)) != 0)))
                {
                    this.drawCentered(score.title, res.titleFont, y);
                    {
                        double x1 = global::System.Math.Floor(((double)((35 * scale))));
                        y += ((int)(x1));
                    }
                }

                if ((!(this.isNullOrEmpty(score.subTitle)) && (((flags & 2)) != 0)))
                {
                    this.drawCentered(score.subTitle, res.subTitleFont, y);
                    {
                        double x2 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x2));
                    }
                }

                if ((!(this.isNullOrEmpty(score.artist)) && (((flags & 4)) != 0)))
                {
                    this.drawCentered(score.artist, res.subTitleFont, y);
                    {
                        double x3 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x3));
                    }
                }

                if ((!(this.isNullOrEmpty(score.album)) && (((flags & 8)) != 0)))
                {
                    this.drawCentered(score.album, res.subTitleFont, y);
                    {
                        double x4 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x4));
                    }
                }

                if (((!(this.isNullOrEmpty(score.music)) && string.Equals(score.music, score.words)) && (((flags & 64)) != 0)))
                {
                    this.drawCentered(global::haxe.lang.Runtime.concat("Music and Words by ", score.words), res.wordsFont, y);
                    {
                        double x5 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x5));
                    }
                }
                else
                {
                    canvas.setFont(res.wordsFont);
                    if ((!(this.isNullOrEmpty(score.music)) && (((flags & 32)) != 0)))
                    {
                        canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Right);
                        canvas.fillText(global::haxe.lang.Runtime.concat("Music by ", score.music), ((double)((this.width - global::alphatab.rendering.layout.PageViewLayout.PagePadding[2]))), ((double)(y)));
                    }

                    if ((!(this.isNullOrEmpty(score.words)) && (((flags & 16)) != 0)))
                    {
                        canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Left);
                        canvas.fillText(global::haxe.lang.Runtime.concat("Words by ", score.music), ((double)(x)), ((double)(y)));
                    }

                    {
                        double x6 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x6));
                    }
                }

                {
                    double x7 = global::System.Math.Floor(((double)((20 * scale))));
                    y += ((int)(x7));
                }

                if (!(this.renderer.track.isPercussion))
                {
                    canvas.setTextAlign(global::alphatab.platform.model.TextAlign.Left);
                    global::alphatab.model.Tuning tuning = global::alphatab.model.Tuning.findTuning(this.renderer.track.tuning);
                    if ((tuning != default(global::alphatab.model.Tuning)))
                    {
                        canvas.setFont(res.effectFont);
                        canvas.fillText(tuning.name, ((double)(x)), ((double)(y)));
                        {
                            double x8 = global::System.Math.Floor(((double)((15 * scale))));
                            y += ((int)(x8));
                        }

                        if (!(tuning.isStandard))
                        {
                            int stringsPerColumn = default(int);
                            {
                                double x9 = global::System.Math.Ceiling(((double)((((double)(this.renderer.track.tuning.length)) / 2))));
                                stringsPerColumn = ((int)(x9));
                            }

                            int currentX = x;
                            int currentY = y;
                            {
                                int _g1 = 0;
                                int _g  = this.renderer.track.tuning.length;
                                while ((_g1 < _g))
                                {
                                    int i = _g1++;
                                    str = global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat(global::haxe.lang.Runtime.concat("(", global::Std.@string((i + 1))), ") = "), global::alphatab.model.Tuning.getTextForTuning(this.renderer.track.tuning[i], false));
                                    canvas.fillText(str, ((double)(currentX)), ((double)(currentY)));
                                    {
                                        double x10 = global::System.Math.Floor(((double)((15 * scale))));
                                        currentY += ((int)(x10));
                                    }

                                    if ((i == (stringsPerColumn - 1)))
                                    {
                                        currentY = y;
                                        {
                                            double x11 = global::System.Math.Floor(((double)((43 * scale))));
                                            currentX += ((int)(x11));
                                        }
                                    }
                                }
                            }

                            int __temp_stmt479 = default(int);
                            {
                                double x12 = global::System.Math.Floor(((double)((15 * scale))));
                                __temp_stmt479 = ((int)(x12));
                            }

                            y += (stringsPerColumn * __temp_stmt479);
                        }
                    }
                }

                {
                    double x13 = global::System.Math.Floor(((double)((25 * scale))));
                    y += ((int)(x13));
                }

                return(y);
            }
        }
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 1405029166:
					{
						this._currentDuration = ((global::alphatab.model.Duration) (@value) );
						return @value;
					}
					
					
					case 1686416180:
					{
						this._allowNegatives = ((bool) (@value) );
						return @value;
					}
					
					
					case 1111114639:
					{
						this._syData = ((object) (@value) );
						return @value;
					}
					
					
					case 4750021:
					{
						this._sy = ((global::alphatab.importer.AlphaTexSymbols) (@value) );
						return @value;
					}
					
					
					case 1424663982:
					{
						this._curChPos = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 4746436:
					{
						this._ch = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 302437836:
					{
						this._track = ((global::alphatab.model.Track) (@value) );
						return @value;
					}
					
					
					case 1958787731:
					{
						this._score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		public virtual   void createDefaultScore()
		{
			unchecked 
			{
				this._score = new global::alphatab.model.Score();
				this._score.tempo = 120;
				this._score.tempoLabel = "";
				this._track = new global::alphatab.model.Track();
				this._track.playbackInfo.program = 25;
				this._track.playbackInfo.primaryChannel = global::alphatab.importer.AlphaTexImporter.TrackChannels[0];
				this._track.playbackInfo.secondaryChannel = global::alphatab.importer.AlphaTexImporter.TrackChannels[1];
				this._track.tuning = ((global::alphatab.model.Tuning) (global::alphatab.model.Tuning.getPresetsFor(6)[0]) ).tuning;
				this._score.addTrack(this._track);
			}
		}
        public virtual void finish(global::alphatab.model.Score score)
        {
            unchecked
            {
                global::haxe.root.Array <object> _g10 = new global::haxe.root.Array <object>(new object[] { this });
                {
                    int _g = 0;
                    global::haxe.root.Array <object> _g1 = score.tracks;
                    while ((_g < _g1.length))
                    {
                        global::alphatab.model.Track t = ((global::alphatab.model.Track)(_g1[_g]));
                        ++_g;
                        if (!(t.isPercussion))
                        {
                            int _g2 = 0;
                            global::haxe.root.Array <object> _g3 = t.bars;
                            while ((_g2 < _g3.length))
                            {
                                global::alphatab.model.Bar bar = ((global::alphatab.model.Bar)(_g3[_g2]));
                                ++_g2;
                                {
                                    int _g4 = 0;
                                    global::haxe.root.Array <object> _g5 = bar.voices;
                                    while ((_g4 < _g5.length))
                                    {
                                        global::alphatab.model.Voice v = ((global::alphatab.model.Voice)(_g5[_g4]));
                                        ++_g4;
                                        {
                                            int _g6 = 0;
                                            global::haxe.root.Array <object> _g7 = v.beats;
                                            while ((_g6 < _g7.length))
                                            {
                                                global::alphatab.model.Beat beat = ((global::alphatab.model.Beat)(_g7[_g6]));
                                                ++_g6;
                                                if (((beat.voice.bar.index == 0) && (beat.index == 0)))
                                                {
                                                    beat.start        = 0;
                                                    beat.previousBeat = default(global::alphatab.model.Beat);
                                                }
                                                else
                                                {
                                                    if ((beat.index == 0))
                                                    {
                                                        beat.previousBeat = ((global::alphatab.model.Beat)(((global::alphatab.model.Voice)(bar.previousBar.voices[v.index])).beats[(((global::alphatab.model.Voice)(bar.previousBar.voices[v.index])).beats.length - 1)]));
                                                    }
                                                    else
                                                    {
                                                        beat.previousBeat = ((global::alphatab.model.Beat)(v.beats[(beat.index - 1)]));
                                                    }

                                                    beat.previousBeat.nextBeat = beat;
                                                    beat.start = (beat.previousBeat.start + beat.previousBeat.calculateDuration());
                                                }

                                                {
                                                    int _g8 = 0;
                                                    global::haxe.root.Array <object> _g9 = beat.notes;
                                                    while ((_g8 < _g9.length))
                                                    {
                                                        global::haxe.root.Array <object> n = new global::haxe.root.Array <object>(new object[] { ((global::alphatab.model.Note)(_g9[_g8])) });
                                                        ++_g8;
                                                        global::alphatab.util.LazyVar <object> nextNoteOnLine = new global::alphatab.util.LazyVar <object>(((global::haxe.lang.Function)(new global::alphatab.importer.ScoreImporter_finish_100__Fun(((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(_g10))))), ((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(n)))))))));
                                                        global::alphatab.util.LazyVar <object> prevNoteOnLine = new global::alphatab.util.LazyVar <object>(((global::haxe.lang.Function)(new global::alphatab.importer.ScoreImporter_finish_101__Fun(((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(_g10))))), ((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(n)))))))));
                                                        if (((global::alphatab.model.Note)(n[0])).isTieDestination)
                                                        {
                                                            if ((((global::alphatab.model.Note)(prevNoteOnLine.getValue())) == default(global::alphatab.model.Note)))
                                                            {
                                                                ((global::alphatab.model.Note)(n[0])).isTieDestination = false;
                                                            }
                                                            else
                                                            {
                                                                ((global::alphatab.model.Note)(n[0])).tieOrigin             = ((global::alphatab.model.Note)(prevNoteOnLine.getValue()));
                                                                ((global::alphatab.model.Note)(n[0])).tieOrigin.isTieOrigin = true;
                                                                ((global::alphatab.model.Note)(n[0])).fret = ((global::alphatab.model.Note)(n[0])).tieOrigin.fret;
                                                            }
                                                        }

                                                        if (((global::alphatab.model.Note)(n[0])).isHammerPullOrigin)
                                                        {
                                                            if ((((global::alphatab.model.Note)(nextNoteOnLine.getValue())) == default(global::alphatab.model.Note)))
                                                            {
                                                                ((global::alphatab.model.Note)(n[0])).isHammerPullOrigin = false;
                                                            }
                                                            else
                                                            {
                                                                ((global::alphatab.model.Note)(nextNoteOnLine.getValue())).isHammerPullDestination = true;
                                                                ((global::alphatab.model.Note)(nextNoteOnLine.getValue())).hammerPullOrigin        = ((global::alphatab.model.Note)(n[0]));
                                                            }
                                                        }

                                                        if ((((global::alphatab.model.Note)(n[0])).slideType != global::alphatab.model.SlideType.None))
                                                        {
                                                            ((global::alphatab.model.Note)(n[0])).slideTarget = ((global::alphatab.model.Note)(nextNoteOnLine.getValue()));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Exemple #13
0
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 1085707415:
					{
						this.chords = ((global::haxe.ds.StringMap<object>) (global::haxe.ds.StringMap<object>.__hx_cast<object>(((global::haxe.ds.StringMap) (@value) ))) );
						return @value;
					}
					
					
					case 1091626816:
					{
						this.bars = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 2027516754:
					{
						this.score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					case 73353859:
					{
						this.isPercussion = ((bool) (@value) );
						return @value;
					}
					
					
					case 983703593:
					{
						this.playbackInfo = ((global::alphatab.model.PlaybackInformation) (@value) );
						return @value;
					}
					
					
					case 1247572323:
					{
						this.color = ((global::alphatab.platform.model.Color) (@value) );
						return @value;
					}
					
					
					case 695082016:
					{
						this.tuningName = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 139280181:
					{
						this.tuning = ((global::haxe.root.Array<int>) (global::haxe.root.Array<object>.__hx_cast<int>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 432148711:
					{
						this.shortName = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 1224700491:
					{
						this.name = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 1041537810:
					{
						this.index = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1102715933:
					{
						this.capo = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Exemple #14
0
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 67859554:
					{
						this.start = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 2027516754:
					{
						this.score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					case 726713937:
					{
						this.volumeAutomation = ((global::alphatab.model.Automation) (@value) );
						return @value;
					}
					
					
					case 288700050:
					{
						this.tempoAutomation = ((global::alphatab.model.Automation) (@value) );
						return @value;
					}
					
					
					case 1574438373:
					{
						this.section = ((global::alphatab.model.Section) (@value) );
						return @value;
					}
					
					
					case 1999551132:
					{
						this.tripletFeel = ((global::alphatab.model.TripletFeel) (@value) );
						return @value;
					}
					
					
					case 1324324830:
					{
						this.timeSignatureNumerator = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 46594619:
					{
						this.timeSignatureDenominator = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1796997604:
					{
						this.repeatGroup = ((global::alphatab.model.RepeatGroup) (@value) );
						return @value;
					}
					
					
					case 462066548:
					{
						this.repeatCount = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1582764861:
					{
						this.isRepeatStart = ((bool) (@value) );
						return @value;
					}
					
					
					case 875656696:
					{
						this.isDoubleBar = ((bool) (@value) );
						return @value;
					}
					
					
					case 1832144217:
					{
						this.keySignature = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1041537810:
					{
						this.index = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 127983386:
					{
						this.previousMasterBar = ((global::alphatab.model.MasterBar) (@value) );
						return @value;
					}
					
					
					case 344334046:
					{
						this.nextMasterBar = ((global::alphatab.model.MasterBar) (@value) );
						return @value;
					}
					
					
					case 1116545170:
					{
						this.alternateEndings = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 1368126571:
					{
						this._playbackInfos = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1249074019:
					{
						this._trackCount = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1623686491:
					{
						this._barCount = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1164415160:
					{
						this._lyricsTrack = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 338202835:
					{
						this._lyrics = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1834786111:
					{
						this._lyricsIndex = ((global::haxe.root.Array<int>) (global::haxe.root.Array<object>.__hx_cast<int>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 822594234:
					{
						this._globalTripletFeel = ((global::alphatab.model.TripletFeel) (@value) );
						return @value;
					}
					
					
					case 498486927:
					{
						this._octave = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1336074296:
					{
						this._keySignature = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 158873116:
					{
						this._tempo = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1958787731:
					{
						this._score = ((global::alphatab.model.Score) (@value) );
						return @value;
					}
					
					
					case 540881986:
					{
						this._versionNumber = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Exemple #16
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 188579043:
                {
                    this.settings = ((global::alphatab.Settings)(@value));
                    return(@value);
                }


                case 307761913:
                {
                    this.renderingResources = ((global::alphatab.rendering.RenderingResources)(@value));
                    return(@value);
                }


                case 1488498346:
                {
                    this.layout = ((global::alphatab.rendering.layout.ScoreLayout)(@value));
                    return(@value);
                }


                case 223048071:
                {
                    this._currentLayoutMode = global::haxe.lang.Runtime.toString(@value);
                    return(@value);
                }


                case 371166859:
                {
                    this.track = ((global::alphatab.model.Track)(@value));
                    return(@value);
                }


                case 2027516754:
                {
                    this.score = ((global::alphatab.model.Score)(@value));
                    return(@value);
                }


                case 943871192:
                {
                    this.canvas = ((global::alphatab.platform.ICanvas)(@value));
                    return(@value);
                }


                case 1842287352:
                {
                    this._renderFinishedListeners = ((global::haxe.root.Array <object>)(global::haxe.root.Array <object> .__hx_cast <object>(((global::haxe.root.Array)(@value)))));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
        public virtual int doScoreInfoLayout(int y)
        {
            unchecked
            {
                int flags = default(int);
                if (this.renderer.settings.layout.@get <bool>("hideInfo", false))
                {
                    flags = 0;
                }
                else
                {
                    flags = 511;
                }

                global::alphatab.model.Score score = this.renderer._get_score();
                double scale = this.renderer.settings.scale;
                if ((!(this.isNullOrEmpty(score.title)) && (((flags & 1)) != 0)))
                {
                    {
                        double x = global::System.Math.Floor(((double)((35 * scale))));
                        y += ((int)(x));
                    }
                }

                if ((!(this.isNullOrEmpty(score.subTitle)) && (((flags & 2)) != 0)))
                {
                    {
                        double x1 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x1));
                    }
                }

                if ((!(this.isNullOrEmpty(score.artist)) && (((flags & 4)) != 0)))
                {
                    {
                        double x2 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x2));
                    }
                }

                if ((!(this.isNullOrEmpty(score.album)) && (((flags & 8)) != 0)))
                {
                    {
                        double x3 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x3));
                    }
                }

                if (((!(this.isNullOrEmpty(score.music)) && string.Equals(score.music, score.words)) && (((flags & 64)) != 0)))
                {
                    {
                        double x4 = global::System.Math.Floor(((double)((20 * scale))));
                        y += ((int)(x4));
                    }
                }
                else
                {
                    if ((!(this.isNullOrEmpty(score.music)) && (((flags & 32)) != 0)))
                    {
                        {
                            double x5 = global::System.Math.Floor(((double)((20 * scale))));
                            y += ((int)(x5));
                        }
                    }

                    if ((!(this.isNullOrEmpty(score.words)) && (((flags & 16)) != 0)))
                    {
                        {
                            double x6 = global::System.Math.Floor(((double)((20 * scale))));
                            y += ((int)(x6));
                        }
                    }
                }

                {
                    double x7 = global::System.Math.Floor(((double)((20 * scale))));
                    y += ((int)(x7));
                }

                if (!(this.renderer.track.isPercussion))
                {
                    global::alphatab.model.Tuning tuning = global::alphatab.model.Tuning.findTuning(this.renderer.track.tuning);
                    if ((tuning != default(global::alphatab.model.Tuning)))
                    {
                        {
                            double x8 = global::System.Math.Floor(((double)((15 * scale))));
                            y += ((int)(x8));
                        }

                        if (!(tuning.isStandard))
                        {
                            int stringsPerColumn = default(int);
                            {
                                double x9 = global::System.Math.Ceiling(((double)((((double)(this.renderer.track.tuning.length)) / 2))));
                                stringsPerColumn = ((int)(x9));
                            }

                            int __temp_stmt478 = default(int);
                            {
                                double x10 = global::System.Math.Floor(((double)((15 * scale))));
                                __temp_stmt478 = ((int)(x10));
                            }

                            y += (stringsPerColumn * __temp_stmt478);
                        }

                        {
                            double x11 = global::System.Math.Floor(((double)((15 * scale))));
                            y += ((int)(x11));
                        }
                    }
                }

                {
                    double x12 = global::System.Math.Floor(((double)((40 * scale))));
                    y += ((int)(x12));
                }

                return(y);
            }
        }