Example #1
0
 public static void __hx_ctor_alphatab_rendering_staves_StaveGroup(global::alphatab.rendering.staves.StaveGroup __temp_me266)
 {
     unchecked
     {
         __temp_me266.bars   = new global::haxe.root.Array <object>();
         __temp_me266.staves = new global::haxe.root.Array <object>();
         __temp_me266.width  = 0;
     }
 }
Example #2
0
        public override void doLayout()
        {
            unchecked
            {
                if ((this.renderer.settings.staves.length == 0))
                {
                    return;
                }

                int startIndex = this.renderer.settings.layout.@get <int>("start", 1);
                startIndex--;
                {
                    double x = default(double);
                    {
                        double b = global::System.Math.Max(((double)(0)), ((double)(startIndex)));
                        x = global::System.Math.Min(((double)((this.renderer.track.bars.length - 1))), ((double)(b)));
                    }

                    startIndex = ((int)(x));
                }

                int currentBarIndex = startIndex;
                int endBarIndex     = this.renderer.settings.layout.@get <int>("count", this.renderer.track.bars.length);
                endBarIndex = ((startIndex + endBarIndex) - 1);
                {
                    double x1 = default(double);
                    {
                        double b1 = global::System.Math.Max(((double)(0)), ((double)(endBarIndex)));
                        x1 = global::System.Math.Min(((double)((this.renderer.track.bars.length - 1))), ((double)(b1)));
                    }

                    endBarIndex = ((int)(x1));
                }

                int x2 = global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[0];
                int y  = global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[1];
                this._group = this.createEmptyStaveGroup();
                while ((currentBarIndex <= endBarIndex))
                {
                    global::alphatab.model.Bar bar = ((global::alphatab.model.Bar)(this.renderer.track.bars[currentBarIndex]));
                    this._group.addBar(bar);
                    currentBarIndex++;
                }

                this._group.x = x2;
                this._group.y = y;
                this._group.finalizeGroup(this);
                y          += (this._group.calculateHeight() + ((int)((20 * this.renderer.settings.scale))));
                this.height = (y + global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[3]);
                this.width  = ((this._group.x + this._group.width) + global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[2]);
            }
        }
Example #3
0
        public virtual void fitGroup(global::alphatab.rendering.staves.StaveGroup @group)
        {
            unchecked
            {
                int barSpace  = 0;
                int freeSpace = (this.getMaxWidth() - @group.width);
                if (((freeSpace != 0) && (@group.bars.length > 0)))
                {
                    barSpace = global::Math.round((((double)(freeSpace)) / @group.bars.length));
                }

                if ((@group.isFull || (barSpace < 0)))
                {
                    @group.applyBarSpacing(barSpace);
                }

                this.width = global::Math.round(global::System.Math.Max(((double)(this.width)), ((double)(@group.width))));
            }
        }
Example #4
0
 public override void paintScore()
 {
     unchecked
     {
         int x = global::alphatab.rendering.layout.PageViewLayout.PagePadding[0];
         int y = global::alphatab.rendering.layout.PageViewLayout.PagePadding[1];
         y = this.paintScoreInfo(x, y);
         {
             int _g = 0;
             global::haxe.root.Array <object> _g1 = this._groups;
             while ((_g < _g1.length))
             {
                 global::alphatab.rendering.staves.StaveGroup g = ((global::alphatab.rendering.staves.StaveGroup)(_g1[_g]));
                 ++_g;
                 g.paint(0, 0, this.renderer.canvas);
             }
         }
     }
 }
Example #5
0
        public virtual global::alphatab.rendering.staves.StaveGroup createStaveGroup(int currentBarIndex, int endIndex)
        {
            unchecked
            {
                global::alphatab.rendering.staves.StaveGroup @group = this.createEmptyStaveGroup();
                int barsPerRow = this.renderer.settings.layout.@get <int>("barsPerRow", -1);
                int maxWidth   = this.getMaxWidth();
                int end        = (endIndex + 1);
                {
                    int _g = currentBarIndex;
                    while ((_g < ((int)(end))))
                    {
                        int i = _g++;
                        global::alphatab.model.Bar bar = ((global::alphatab.model.Bar)(this.renderer.track.bars[i]));
                        @group.addBar(bar);
                        bool groupIsFull = false;
                        if (((barsPerRow == -1) && (((@group.width >= maxWidth) && (@group.bars.length != 0)))))
                        {
                            groupIsFull = true;
                        }
                        else
                        {
                            if ((@group.bars.length == (barsPerRow + 1)))
                            {
                                groupIsFull = true;
                            }
                        }

                        if (groupIsFull)
                        {
                            @group.revertLastBar();
                            @group.isFull = true;
                            return(@group);
                        }

                        @group.x = 0;
                    }
                }

                return(@group);
            }
        }
Example #6
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 366738048:
                {
                    this._group = ((global::alphatab.rendering.staves.StaveGroup)(@value));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
Example #7
0
        public virtual global::alphatab.rendering.staves.StaveGroup createEmptyStaveGroup()
        {
            unchecked
            {
                global::alphatab.rendering.staves.StaveGroup @group = new global::alphatab.rendering.staves.StaveGroup();
                @group.layout = this;
                {
                    int _g = 0;
                    global::haxe.root.Array <object> _g1 = this.renderer.settings.staves;
                    while ((_g < _g1.length))
                    {
                        global::alphatab.StaveSettings s = ((global::alphatab.StaveSettings)(_g1[_g]));
                        ++_g;
                        if (global::alphatab.Environment.staveFactories.exists(s.id))
                        {
                            @group.addStave(new global::alphatab.rendering.staves.Stave(((global::alphatab.rendering.BarRendererFactory)(((global::haxe.lang.Function)(global::alphatab.Environment.staveFactories.@get(s.id).@value)).__hx_invoke1_o(default(double), this)))));
                        }
                    }
                }

                return(@group);
            }
        }
		public override   void doLayout()
		{
			unchecked 
			{
				if (( this.renderer.settings.staves.length == 0 )) 
				{
					return ;
				}
				
				int startIndex = this.renderer.settings.layout.@get<int>("start", 1);
				startIndex--;
				{
					double x = default(double);
					{
						double b = global::System.Math.Max(((double) (0) ), ((double) (startIndex) ));
						x = global::System.Math.Min(((double) (( this.renderer.track.bars.length - 1 )) ), ((double) (b) ));
					}
					
					startIndex = ((int) (x) );
				}
				
				int currentBarIndex = startIndex;
				int endBarIndex = this.renderer.settings.layout.@get<int>("count", this.renderer.track.bars.length);
				endBarIndex = ( ( startIndex + endBarIndex ) - 1 );
				{
					double x1 = default(double);
					{
						double b1 = global::System.Math.Max(((double) (0) ), ((double) (endBarIndex) ));
						x1 = global::System.Math.Min(((double) (( this.renderer.track.bars.length - 1 )) ), ((double) (b1) ));
					}
					
					endBarIndex = ((int) (x1) );
				}
				
				int x2 = global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[0];
				int y = global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[1];
				this._group = this.createEmptyStaveGroup();
				while (( currentBarIndex <= endBarIndex ))
				{
					global::alphatab.model.Bar bar = ((global::alphatab.model.Bar) (this.renderer.track.bars[currentBarIndex]) );
					this._group.addBar(bar);
					currentBarIndex++;
				}
				
				this._group.x = x2;
				this._group.y = y;
				this._group.finalizeGroup(this);
				y += ( this._group.calculateHeight() + ((int) (( 20 * this.renderer.settings.scale )) ) );
				this.height = ( y + global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[3] );
				this.width = ( ( this._group.x + this._group.width ) + global::alphatab.rendering.layout.HorizontalScreenLayout.PagePadding[2] );
			}
		}
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 366738048:
					{
						this._group = ((global::alphatab.rendering.staves.StaveGroup) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Example #10
0
		public override   object __hx_setField(string field, int hash, object @value, bool handleProperties)
		{
			unchecked 
			{
				switch (hash)
				{
					case 553915593:
					{
						this.isLastInAccolade = ((bool) (@value) );
						return @value;
					}
					
					
					case 504792271:
					{
						this.isFirstInAccolade = ((bool) (@value) );
						return @value;
					}
					
					
					case 1382488090:
					{
						this.staveBottom = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1818949592:
					{
						this.bottomSpacing = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 2106138990:
					{
						this.topSpacing = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 105656838:
					{
						this.staveTop = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 1041537810:
					{
						this.index = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 38537191:
					{
						this.height = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 121:
					{
						this.y = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 120:
					{
						this.x = ((int) (global::haxe.lang.Runtime.toInt(@value)) );
						return @value;
					}
					
					
					case 268153213:
					{
						this.barRenderers = ((global::haxe.root.Array<object>) (global::haxe.root.Array<object>.__hx_cast<object>(((global::haxe.root.Array) (@value) ))) );
						return @value;
					}
					
					
					case 1636857419:
					{
						this._factory = ((global::alphatab.rendering.BarRendererFactory) (@value) );
						return @value;
					}
					
					
					case 1560739056:
					{
						this.staveGroup = ((global::alphatab.rendering.staves.StaveGroup) (@value) );
						return @value;
					}
					
					
					default:
					{
						return base.__hx_setField(field, hash, @value, handleProperties);
					}
					
				}
				
			}
		}
Example #11
0
		public virtual   global::alphatab.rendering.staves.StaveGroup createEmptyStaveGroup()
		{
			unchecked 
			{
				global::alphatab.rendering.staves.StaveGroup @group = new global::alphatab.rendering.staves.StaveGroup();
				@group.layout = this;
				{
					int _g = 0;
					global::haxe.root.Array<object> _g1 = this.renderer.settings.staves;
					while (( _g < _g1.length ))
					{
						global::alphatab.StaveSettings s = ((global::alphatab.StaveSettings) (_g1[_g]) );
						 ++ _g;
						if (global::alphatab.Environment.staveFactories.exists(s.id)) 
						{
							@group.addStave(new global::alphatab.rendering.staves.Stave(((global::alphatab.rendering.BarRendererFactory) (((global::haxe.lang.Function) (global::alphatab.Environment.staveFactories.@get(s.id).@value) ).__hx_invoke1_o(default(double), this)) )));
						}
						
					}
					
				}
				
				return @group;
			}
		}
Example #12
0
        public override object __hx_setField(string field, int hash, object @value, bool handleProperties)
        {
            unchecked
            {
                switch (hash)
                {
                case 553915593:
                {
                    this.isLastInAccolade = ((bool)(@value));
                    return(@value);
                }


                case 504792271:
                {
                    this.isFirstInAccolade = ((bool)(@value));
                    return(@value);
                }


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


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


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


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


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


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


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


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


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


                case 1636857419:
                {
                    this._factory = ((global::alphatab.rendering.BarRendererFactory)(@value));
                    return(@value);
                }


                case 1560739056:
                {
                    this.staveGroup = ((global::alphatab.rendering.staves.StaveGroup)(@value));
                    return(@value);
                }


                default:
                {
                    return(base.__hx_setField(field, hash, @value, handleProperties));
                }
                }
            }
        }
Example #13
0
        public override void doLayout()
        {
            unchecked
            {
                this._groups = new global::haxe.root.Array <object>();
                int startIndex = this.renderer.settings.layout.@get <int>("start", 1);
                startIndex--;
                {
                    double x = default(double);
                    {
                        double b = global::System.Math.Max(((double)(0)), ((double)(startIndex)));
                        x = global::System.Math.Min(((double)((this.renderer.track.bars.length - 1))), ((double)(b)));
                    }

                    startIndex = ((int)(x));
                }

                int currentBarIndex = startIndex;
                int endBarIndex     = this.renderer.settings.layout.@get <int>("count", this.renderer.track.bars.length);
                if ((endBarIndex < 0))
                {
                    endBarIndex = this.renderer.track.bars.length;
                }

                endBarIndex = ((startIndex + endBarIndex) - 1);
                {
                    double x1 = default(double);
                    {
                        double b1 = global::System.Math.Max(((double)(0)), ((double)(endBarIndex)));
                        x1 = global::System.Math.Min(((double)((this.renderer.track.bars.length - 1))), ((double)(b1)));
                    }

                    endBarIndex = ((int)(x1));
                }

                int x2 = global::alphatab.rendering.layout.PageViewLayout.PagePadding[0];
                int y  = global::alphatab.rendering.layout.PageViewLayout.PagePadding[1];
                y = this.doScoreInfoLayout(y);
                bool autoSize = this.renderer.settings.layout.@get <bool>("autoSize", true);
                if ((autoSize || (this.renderer.settings.width <= 0)))
                {
                    this.width = ((int)((950 * this.renderer.settings.scale)));
                }
                else
                {
                    this.width = this.renderer.settings.width;
                }

                if ((this.renderer.settings.staves.length > 0))
                {
                    while ((currentBarIndex <= endBarIndex))
                    {
                        global::alphatab.rendering.staves.StaveGroup @group = this.createStaveGroup(currentBarIndex, endBarIndex);
                        this._groups.push(@group);
                        @group.x = x2;
                        @group.y = y;
                        this.fitGroup(@group);
                        @group.finalizeGroup(this);
                        y += (@group.calculateHeight() + ((int)((20 * this.renderer.settings.scale))));
                        currentBarIndex = (((global::alphatab.model.Bar)(@group.bars[(@group.bars.length - 1)])).index + 1);
                    }
                }

                this.height = (y + global::alphatab.rendering.layout.PageViewLayout.PagePadding[3]);
            }
        }