Example #1
0
 public static void __hx_ctor_alphatab_model_Voice(global::alphatab.model.Voice __temp_me88)
 {
     unchecked
     {
         __temp_me88.beats = new global::haxe.root.Array <object>();
     }
 }
Example #2
0
 public virtual void addVoice(global::alphatab.model.Voice voice)
 {
     unchecked
     {
         voice.bar   = this;
         voice.index = this.voices.length;
         this.voices.push(voice);
     }
 }
Example #3
0
 public virtual void createVoiceGlyphs(global::alphatab.model.Voice v)
 {
     unchecked
     {
         int _g = 0;
         global::haxe.root.Array <object> _g1 = v.beats;
         while ((_g < _g1.length))
         {
             global::alphatab.model.Beat b = ((global::alphatab.model.Beat)(_g1[_g]));
             ++_g;
             global::alphatab.rendering.glyphs.TabBeatContainerGlyph container = new global::alphatab.rendering.glyphs.TabBeatContainerGlyph(((global::alphatab.model.Beat)(b)));
             container.preNotes  = new global::alphatab.rendering.glyphs.TabBeatPreNotesGlyph();
             container.onNotes   = new global::alphatab.rendering.glyphs.TabBeatGlyph();
             container.postNotes = new global::alphatab.rendering.glyphs.TabBeatPostNotesGlyph();
             this.addBeatGlyph(container);
         }
     }
 }
Example #4
0
        public virtual bool isEmpty()
        {
            unchecked
            {
                {
                    int _g = 0;
                    global::haxe.root.Array <object> _g1 = this.voices;
                    while ((_g < _g1.length))
                    {
                        global::alphatab.model.Voice v = ((global::alphatab.model.Voice)(_g1[_g]));
                        ++_g;
                        if (!(v.isEmpty()))
                        {
                            return(false);
                        }
                    }
                }

                return(true);
            }
        }
Example #5
0
        public virtual bool checkBeat(global::alphatab.model.Beat beat)
        {
            unchecked
            {
                if ((this.voice == default(global::alphatab.model.Voice)))
                {
                    this.voice = beat.voice;
                }

                bool @add = false;
                if ((this.beats.length == 0))
                {
                    @add = true;
                }
                else
                {
                    if (global::alphatab.rendering.utils.BeamingHelper.canJoin(this._lastBeat, beat))
                    {
                        @add = true;
                    }
                }

                if (@add)
                {
                    this._lastBeat = beat;
                    this.beats.push(beat);
                    this.checkNote(beat.minNote());
                    this.checkNote(beat.maxNote());
                    if ((global::alphatab.model.ModelUtils.getDurationValue(this.maxDuration) < global::alphatab.model.ModelUtils.getDurationValue(beat.duration)))
                    {
                        this.maxDuration = beat.duration;
                    }
                }

                return(@add);
            }
        }
Example #6
0
        public virtual void createVoiceGlyphs(global::alphatab.model.Voice v)
        {
            unchecked
            {
                int _g = 0;
                global::haxe.root.Array <object> _g1 = v.beats;
                while ((_g < _g1.length))
                {
                    global::alphatab.model.Beat b = ((global::alphatab.model.Beat)(_g1[_g]));
                    ++_g;
                    global::alphatab.rendering.glyphs.BeatContainerGlyph container = new global::alphatab.rendering.glyphs.BeatContainerGlyph(((global::alphatab.model.Beat)(b)));
                    container.preNotes  = new global::alphatab.rendering.glyphs.BeatGlyphBase();
                    container.onNotes   = new global::alphatab.rendering.glyphs.BeatGlyphBase();
                    container.postNotes = new global::alphatab.rendering.glyphs.BeatGlyphBase();
                    this.addBeatGlyph(container);
                    if (this._info.shouldCreateGlyph(this, b))
                    {
                        this.createOrResizeGlyph(this._info.getSizingMode(), b);
                    }

                    this._lastBeat = b;
                }
            }
        }
Example #7
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 448361819:
                {
                    this._beatLineXPositions = ((global::haxe.ds.IntMap <object>)(global::haxe.ds.IntMap <object> .__hx_cast <object>(((global::haxe.ds.IntMap)(@value)))));
                    return(@value);
                }


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


                case 1228566710:
                {
                    this.maxNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 974358180:
                {
                    this.minNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 2112234752:
                {
                    this.lastMaxNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 1858026222:
                {
                    this.lastMinNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 1921156710:
                {
                    this.firstMaxNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 1666948180:
                {
                    this.firstMinNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 173283864:
                {
                    this.maxDuration = ((global::alphatab.model.Duration)(@value));
                    return(@value);
                }


                case 468906571:
                {
                    this._lastBeat = ((global::alphatab.model.Beat)(@value));
                    return(@value);
                }


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


                case 989275570:
                {
                    this.voice = ((global::alphatab.model.Voice)(@value));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
Example #8
0
		public virtual   void parseVoice(global::haxe.root.Xml node)
		{
			unchecked 
			{
				global::alphatab.model.Voice voice = new global::alphatab.model.Voice();
				string voiceId = node.@get("id");
				{
					object __temp_iterator432 = node.iterator();
					while (((bool) (global::haxe.lang.Runtime.callField(__temp_iterator432, "hasNext", 407283053, default(global::haxe.root.Array))) ))
					{
						global::haxe.root.Xml c = ((global::haxe.root.Xml) (global::haxe.lang.Runtime.callField(__temp_iterator432, "next", 1224901875, default(global::haxe.root.Array))) );
						if (( c.nodeType == global::haxe.root.Xml.Element )) 
						{
							string _g = c._get_nodeName();
							switch (_g)
							{
								case "Beats":
								{
									this._beatsOfVoice.@set(voiceId, global::haxe.lang.StringExt.split(this.getValue(c), " "));
									break;
								}
								
								
							}
							
						}
						
					}
					
				}
				
				this._voiceById.@set(voiceId, voice);
			}
		}
Example #9
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 1751303026:
                {
                    this.dynamicValue = ((global::alphatab.model.DynamicValue)(@value));
                    return(@value);
                }


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


                case 848728090:
                {
                    this.crescendo = ((global::alphatab.rendering.glyphs.CrescendoType)(@value));
                    return(@value);
                }


                case 706091227:
                {
                    this.tremoloSpeed = new global::haxe.lang.Null <global::alphatab.model.Duration>(global::haxe.lang.Null <object> .ofDynamic <global::alphatab.model.Duration>(@value).@value, true);
                    return(@value);
                }


                case 1801219961:
                {
                    this.pickStroke = ((global::alphatab.model.PickStrokeType)(@value));
                    return(@value);
                }


                case 233406162:
                {
                    this.graceType = ((global::alphatab.model.GraceType)(@value));
                    return(@value);
                }


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


                case 1598475321:
                {
                    this.vibrato = ((global::alphatab.model.VibratoType)(@value));
                    return(@value);
                }


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


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


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


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


                case 1321811028:
                {
                    this.brushType = ((global::alphatab.model.BrushType)(@value));
                    return(@value);
                }


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


                case 5790307:
                {
                    this.tap = ((bool)(@value));
                    return(@value);
                }


                case 1280692680:
                {
                    this.slap = ((bool)(@value));
                    return(@value);
                }


                case 650430015:
                {
                    this.hasRasgueado = ((bool)(@value));
                    return(@value);
                }


                case 5594513:
                {
                    this.pop = ((bool)(@value));
                    return(@value);
                }


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


                case 1688947841:
                {
                    this.fadeIn = ((bool)(@value));
                    return(@value);
                }


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


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


                case 207609411:
                {
                    this.isEmpty = ((bool)(@value));
                    return(@value);
                }


                case 344854356:
                {
                    this.duration = ((global::alphatab.model.Duration)(@value));
                    return(@value);
                }


                case 49465911:
                {
                    this._maxNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


                case 1942741029:
                {
                    this._minNote = ((global::alphatab.model.Note)(@value));
                    return(@value);
                }


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


                case 989275570:
                {
                    this.voice = ((global::alphatab.model.Voice)(@value));
                    return(@value);
                }


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


                case 1826654217:
                {
                    this.nextBeat = ((global::alphatab.model.Beat)(@value));
                    return(@value);
                }


                case 1739960653:
                {
                    this.previousBeat = ((global::alphatab.model.Beat)(@value));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
		public virtual   void readVoice(global::alphatab.model.Track track, global::alphatab.model.Bar bar)
		{
			unchecked 
			{
				int beatCount = this.readInt32();
				if (( beatCount == 0 )) 
				{
					return ;
				}
				
				global::alphatab.model.Voice newVoice = new global::alphatab.model.Voice();
				bar.addVoice(newVoice);
				{
					int _g = 0;
					while (( _g < ((int) (beatCount) ) ))
					{
						int i = _g++;
						this.readBeat(track, bar, newVoice);
					}
					
				}
				
			}
		}
		public virtual   void bar()
		{
			unchecked 
			{
				global::alphatab.model.MasterBar master = new global::alphatab.model.MasterBar();
				this._score.addMasterBar(master);
				global::alphatab.model.Bar bar = new global::alphatab.model.Bar();
				this._track.addBar(bar);
				if (( master.index > 0 )) 
				{
					master.keySignature = master.previousMasterBar.keySignature;
					master.timeSignatureDenominator = master.previousMasterBar.timeSignatureDenominator;
					master.timeSignatureNumerator = master.previousMasterBar.timeSignatureNumerator;
					bar.clef = bar.previousBar.clef;
				}
				
				this.barMeta(bar);
				global::alphatab.model.Voice voice = new global::alphatab.model.Voice();
				bar.addVoice(voice);
				while (( ( this._sy != global::alphatab.importer.AlphaTexSymbols.Pipe ) && ( this._sy != global::alphatab.importer.AlphaTexSymbols.Eof ) ))
				{
					this.beat(voice);
				}
				
			}
		}
Example #12
0
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 448361819:
					{
						this._beatLineXPositions = ((global::haxe.ds.IntMap<object>) (global::haxe.ds.IntMap<object>.__hx_cast<object>(((global::haxe.ds.IntMap) (@value) ))) );
						return @value;
					}
					
					
					case 302437836:
					{
						this._track = ((global::alphatab.model.Track) (@value) );
						return @value;
					}
					
					
					case 1228566710:
					{
						this.maxNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 974358180:
					{
						this.minNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 2112234752:
					{
						this.lastMaxNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 1858026222:
					{
						this.lastMinNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 1921156710:
					{
						this.firstMaxNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 1666948180:
					{
						this.firstMinNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 173283864:
					{
						this.maxDuration = ((global::alphatab.model.Duration) (@value) );
						return @value;
					}
					
					
					case 468906571:
					{
						this._lastBeat = ((global::alphatab.model.Beat) (@value) );
						return @value;
					}
					
					
					case 810640957:
					{
						this.beats = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 989275570:
					{
						this.voice = ((global::alphatab.model.Voice) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Example #13
0
		public virtual   bool checkBeat(global::alphatab.model.Beat beat)
		{
			unchecked 
			{
				if (( this.voice == default(global::alphatab.model.Voice) )) 
				{
					this.voice = beat.voice;
				}
				
				bool @add = false;
				if (( this.beats.length == 0 )) 
				{
					@add = true;
				}
				 else 
				{
					if (global::alphatab.rendering.utils.BeamingHelper.canJoin(this._lastBeat, beat)) 
					{
						@add = true;
					}
					
				}
				
				if (@add) 
				{
					this._lastBeat = beat;
					this.beats.push(beat);
					this.checkNote(beat.minNote());
					this.checkNote(beat.maxNote());
					if (( global::alphatab.model.ModelUtils.getDurationValue(this.maxDuration) < global::alphatab.model.ModelUtils.getDurationValue(beat.duration) )) 
					{
						this.maxDuration = beat.duration;
					}
					
				}
				
				return @add;
			}
		}
Example #14
0
        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()));
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
Example #15
0
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 1751303026:
					{
						this.dynamicValue = ((global::alphatab.model.DynamicValue) (@value) );
						return @value;
					}
					
					
					case 67859554:
					{
						this.start = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 848728090:
					{
						this.crescendo = ((global::alphatab.rendering.glyphs.CrescendoType) (@value) );
						return @value;
					}
					
					
					case 706091227:
					{
						this.tremoloSpeed = new global::haxe.lang.Null<global::alphatab.model.Duration>(global::haxe.lang.Null<object>.ofDynamic<global::alphatab.model.Duration>(@value).@value, true);
						return @value;
					}
					
					
					case 1801219961:
					{
						this.pickStroke = ((global::alphatab.model.PickStrokeType) (@value) );
						return @value;
					}
					
					
					case 233406162:
					{
						this.graceType = ((global::alphatab.model.GraceType) (@value) );
						return @value;
					}
					
					
					case 1594575703:
					{
						this.chordId = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 1598475321:
					{
						this.vibrato = ((global::alphatab.model.VibratoType) (@value) );
						return @value;
					}
					
					
					case 1147430701:
					{
						this.whammyBarPoints = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 438479229:
					{
						this.tupletNumerator = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1310257562:
					{
						this.tupletDenominator = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1650208238:
					{
						this.brushDuration = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1321811028:
					{
						this.brushType = ((global::alphatab.model.BrushType) (@value) );
						return @value;
					}
					
					
					case 1291439277:
					{
						this.text = global::haxe.lang.Runtime.toString(@value);
						return @value;
					}
					
					
					case 5790307:
					{
						this.tap = ((bool) (@value) );
						return @value;
					}
					
					
					case 1280692680:
					{
						this.slap = ((bool) (@value) );
						return @value;
					}
					
					
					case 650430015:
					{
						this.hasRasgueado = ((bool) (@value) );
						return @value;
					}
					
					
					case 5594513:
					{
						this.pop = ((bool) (@value) );
						return @value;
					}
					
					
					case 632389428:
					{
						this.lyrics = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1688947841:
					{
						this.fadeIn = ((bool) (@value) );
						return @value;
					}
					
					
					case 1114502602:
					{
						this.dots = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 638277820:
					{
						this.automations = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 207609411:
					{
						this.isEmpty = ((bool) (@value) );
						return @value;
					}
					
					
					case 344854356:
					{
						this.duration = ((global::alphatab.model.Duration) (@value) );
						return @value;
					}
					
					
					case 49465911:
					{
						this._maxNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 1942741029:
					{
						this._minNote = ((global::alphatab.model.Note) (@value) );
						return @value;
					}
					
					
					case 533388353:
					{
						this.notes = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 989275570:
					{
						this.voice = ((global::alphatab.model.Voice) (@value) );
						return @value;
					}
					
					
					case 1041537810:
					{
						this.index = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1826654217:
					{
						this.nextBeat = ((global::alphatab.model.Beat) (@value) );
						return @value;
					}
					
					
					case 1739960653:
					{
						this.previousBeat = ((global::alphatab.model.Beat) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}