예제 #1
0
 public static void PopParams()
 {
     if (parameterStack.Count > 0)
     {
         activeParameters = parameterStack.Pop();
     }
 }
예제 #2
0
        /**
         * Draws this item's representation
         */
        public override void Draw()
        {
            Engine.PerformanceStatsInProgress.GuiUpdates++;

            if (ItemInstance != null)
            {
                var            item = ItemInstance.Item;
                Sprite         icon = CoM.Instance.ItemIconSprites[item.IconID];
                DrawParameters dp   = DrawParameters.Default;

                int offsetX = (int)((Width) - icon.rect.width) / 2;
                int offsetY = (int)((Height) - icon.rect.height) / 2;

                SmartUI.Color = Color;
                dp.Transform  = ColorTransform;

                if (BeingDragged || !Enabled)
                {
                    SmartUI.Color = Color.gray;
                    dp            = DrawParameters.BlackAndWhite;
                }

                SmartUI.Draw(X + offsetX, Y + offsetY, icon, dp);
                SmartUI.Color = Color.white;

                if (ItemInstance.Item.Usable)
                {
                    GUIStyle myStyle = CoM.SubtextStyle;
                    myStyle.alignment = TextAnchor.LowerLeft;
                    SmartUI.TextWithShadow(new Rect(X + offsetX + 2, Y + offsetY, 40, 35), ItemInstance.RemainingCharges.ToString(), myStyle, 1);
                }
            }
        }
예제 #3
0
 public override void Draw(DrawParameters p)
 {
     if (this.isTriggered)
     {
         base.Draw(p);
     }
 }
예제 #4
0
        public CodeViewTab(ArmAssembly.ArmFileInfo progInfo, ApplicationJimulator jm)
        {
            JM  = jm;
            _PI = progInfo;
            string fileName = progInfo.FileName;

            InitializeComponent();

            this.SuspendLayout();
            this.Location = new System.Drawing.Point(4, 22);
            this.Name     = fileName;
            this.Size     = new System.Drawing.Size(464, 312);
            this.TabIndex = 0;
            this.Text     = Path.GetFileName(fileName);

            _codeViewList                 = new CodeViewList(this);
            _codeViewList.DrawItem       += this.drawItem;
            _codeViewList.VisibleChanged += this.createLines;
            this.Controls.Add(_codeViewList);

            this.fileSystemWatcher1.Path   = Path.GetDirectoryName(fileName);
            this.fileSystemWatcher1.Filter = Path.GetFileName(fileName);
            //_fileChanged = false;
            this.ResumeLayout(false);

            _drawParameters = new DrawParameters(_codeViewList.CreateGraphics(), _codeViewList.Font);
        }
예제 #5
0
        public override void Draw(DrawingContext dc, DrawParameters parameters)
        {
            double radius = this.Radius;

            if (IsSelected)
            {
                // draw highlight
                dc.DrawEllipse(highlightBrush, null, Position, radius + 5, radius + 5);
            }

            dc.DrawEllipse(brush, null, Position, radius, radius);

            if (parameters.ZoomLevel > DetailThreshold)
            {
                // draw text
                //Point textPosition = new Point(Position.X - formattedText.Width / 2, Position.Y + radius);
                //dc.DrawText(formattedText, textPosition);

                // draw image
                if (image != null)
                {
                    double width  = radius * 1.4;
                    double height = radius * 1.4;

                    Rect imageRect = new Rect(Position.X - width / 2, Position.Y - height / 2, width, height);

                    dc.DrawImage(image, imageRect);
                }
            }
        }
예제 #6
0
        public void DrawDebug(DrawParameters p)
        {
            if (!(this is XImage) && !(this is XBlock))
            {
                return;
            }

            tmpBounds = this.GetScreenBounds();

#if WINDOWS
            tmpVector1 = MouseProcessor.LastPosition;
#else
            tmpVector1 = TouchPanelProcessor.LastPosition;
#endif

            if (!tmpBounds.Contains((int)tmpVector1.X, (int)tmpVector1.Y))
            {
                return;
            }

            Color c = Color.Red * 0.3f;


            p.SpriteBatch.Draw(p.Game.BlankTexture, tmpBounds, c);

            if (!string.IsNullOrEmpty(this.Id))
            {
                tmpVector1.X = tmpBounds.X;
                tmpVector1.Y = tmpBounds.Y;

                p.SpriteBatch.DrawString(p.Game.SystemFont, this.Id, tmpVector1, Color.Yellow);
            }
        }
예제 #7
0
        void DrawActualSize(DrawParameters p)
        {
            // we're using location
            this.tmpVector1.X = this.PropState.ScreenBounds.Value.X;
            this.tmpVector1.Y = this.PropState.ScreenBounds.Value.Y;

            p.SpriteBatch.Draw(this.texture.Image, this.tmpVector1, this.SourceRectangle, actualBackColor, (float)screenRotation, this.Origin, this.PropState.Scale, (SpriteEffects)this.FlipEffects, this.PropState.Depth + p.NextSystemImageDepth());
        }
예제 #8
0
        public override void Draw(DrawParameters p)
        {
            base.Draw(p);

            if (p.Game.GameObject.ShowDebugInfo && p.Game.DrawDebugInfo)
            {
                DrawDebug(p);
            }
        }
예제 #9
0
        public override void Draw(DrawingContext dc, DrawParameters parameters)
        {
            dc.DrawLine(pen, From.Position, To.Position);

            //if (parameters.ZoomLevel > DetailThreshold)
            //{
            //    Point position = VectorTools.MidPoint(From.Position, To.Position);
            //    Point textPosition = new Point(position.X - formattedText.Width / 2, position.Y - formattedText.Height / 2);

            //    dc.DrawText(formattedText, textPosition);
            //}
        }
예제 #10
0
파일: XText.cs 프로젝트: valsavva/dynacat
        public override void Draw(DrawParameters p)
        {
            if (this.PropState.ScreenBounds.HasValue)
            {
                this.location.X = this.PropState.ScreenBounds.Value.X;
                this.location.Y = this.PropState.ScreenBounds.Value.Y;

                p.SpriteBatch.DrawString(this.font.Font, GetText(), this.location, actualColor, (float)screenRotation, this.Origin, this.PropState.Scale, (SpriteEffects)this.FlipEffects, this.Depth + p.NextSystemImageDepth());
            }

            base.Draw(p);
        }
예제 #11
0
파일: XText.cs 프로젝트: valsavva/dynacat
		public override void Draw(DrawParameters p)
		{
			if (this.PropState.ScreenBounds.HasValue)
			{
				this.location.X = this.PropState.ScreenBounds.Value.X;
				this.location.Y = this.PropState.ScreenBounds.Value.Y;
				
				p.SpriteBatch.DrawString(this.font.Font, GetText(), this.location, actualColor, (float)screenRotation, this.Origin, this.PropState.Scale, (SpriteEffects)this.FlipEffects, this.Depth + p.NextSystemImageDepth());
			}
			
			base.Draw(p);
		}
예제 #12
0
 /// <summary>
 /// This method represents the draw stage of the four primary stages of the component lifecycle
 /// (hierarchy building, component initialization, update and draw, dispose).
 /// <remarks>
 /// The <see cref="Draw"/> method is responsible for rendering the component on the screen. This is where
 /// the XGAME framework integrates with thatever the underlying graphics technolody is used.
 /// </remarks>
 /// </summary>
 public virtual void Draw(DrawParameters p)
 {
     if (this.Subcomponents != null)
     {
         for (int i = 0; i < this.Subcomponents.Count; i++)
         {
             var subcomponent = this.Subcomponents[i];
             if (subcomponent.Enabled)
             {
                 subcomponent.Draw(p);
             }
         }
     }
 }
예제 #13
0
            }//ctor lstLine for ARM instruction

            public ListLine(DrawParameters drawParameters, string text, uint address, string hexContents, CodeViewTab parent)
                : base(drawParameters, text, parent)
            {
                Address          = address;
                this.hexContents = hexContents;
                if (hexContents.Length == 8)
                {
                    opcodeBytes = 4;
                }
                else if (hexContents.Length == 4)
                {
                    opcodeBytes = 2;
                }
                addressValid = true;
            }//ctor lstLine for ARM instruction
예제 #14
0
        public override void Draw(DrawParameters p)
        {
            if (this.PropState.ScreenBounds.HasValue)
            {
                this.tmpBounds = this.PropState.ScreenBounds.Value;
                if (GameEngine.Instance.Scale2D != Vector2.One)
                {
                    var bounds = this.PropState.ScreenBounds.Value;
                    bounds.Width  += 1;
                    bounds.Height += 1;
                    this.PropState.ScreenBounds = bounds;
                }

                // first resolve the actual way we want to draw the image
                XImageStretchMode actualStretchMode = this.StretchMode;

                if (actualStretchMode == XImageStretchMode.Auto)
                {
                    if ((this.Bounds.X != 0 || this.Bounds.Y != 0) && this.Bounds.Width == 0 && this.Bounds.Height == 0)
                    {
                        actualStretchMode = XImageStretchMode.ActualSize;
                    }
                    else
                    {
                        actualStretchMode = XImageStretchMode.Stretch;
                    }
                }

                // draw it
                if (actualStretchMode == XImageStretchMode.ActualSize)
                {
                    DrawActualSize(p);
                }
                else if (actualStretchMode == XImageStretchMode.Stretch)
                {
                    DrawStretched(p);
                }
                else
                {
                    DrawTiles(p);
                }

                this.PropState.ScreenBounds = this.tmpBounds;
            }
            base.Draw(p);
        }
예제 #15
0
        /** Draws the sprite */
        public override void DrawContents()
        {
            if (Sprite != null)
            {
                DrawParameters dp = GetDrawParameters;
                dp.AlphaBlend = AlphaBlend;
                dp.Scale      = new Vector2(ContentsFrame.width / Sprite.rect.width, ContentsFrame.height / Sprite.rect.height);
                dp.Rotation   = Rotation;

                if (!ImageColorTransform.IsIdentity)
                {
                    dp.Transform = dp.Transform + ImageColorTransform;
                }

                SmartUI.Color = Color * ImageColor;
                SmartUI.Draw(0, 0, Sprite, dp);
                SmartUI.Color = Color.white;
            }
        }
예제 #16
0
    public static void Draw(Rect screenRect, GUIStyle style, DrawParameters dp, SmartStyleState state = SmartStyleState.Normal)
    {
        Texture2D texture = style.normal.background;

        switch (state)
        {
        case SmartStyleState.Deactivated:
            texture = style.active.background ?? texture;
            break;

        case SmartStyleState.Depressed:
            texture = style.focused.background ?? texture;
            break;

        case SmartStyleState.Selected:
            texture = style.onActive.background ?? texture;
            break;

        case SmartStyleState.Hover:
            texture = style.hover.background ?? texture;
            break;
        }

        if (texture == null)
        {
            return;
        }

        Rect uvFrame = new Rect(0, 0, texture.width, texture.height);

        if (style.fixedHeight != 0f)
        {
            screenRect.height = style.fixedHeight;
        }
        if (style.fixedWidth != 0f)
        {
            screenRect.width = style.fixedWidth;
        }
        screenRect = style.overflow.Add(screenRect);
        DrawMaster(screenRect, texture, uvFrame, dp, style.border);
    }
예제 #17
0
        public override void Draw()
        {
            if (CompositeAlpha <= 0f)
            {
                return;
            }

            if (hasRenderTexture && SmartUI.isRepaint && !forceStandardDraw)
            {
                // setup for render texture draw
                var dp = (CacheMode == CacheMode.Solid) ? DrawParameters.NoAlpha : DrawParameters.Default;
                dp.Transform = CompositeColorTransform;
                if (repaintedTextureThisFrame && Settings.Advanced.ShowCacheRenders)
                {
                    dp = new DrawParameters(ColorTransform.TintAndMultiply(Color.red, Color.gray));
                }
                if (CompositeAlpha < 1f)
                {
                    var colorOffset = dp.Transform.ColorOffset;
                    colorOffset[3]           = ((1f - colorOffset[3]) * CompositeAlpha) - 1f;
                    dp.Transform.ColorOffset = colorOffset;
                    dp.AlphaBlend            = true;
                }
                SmartUI.Draw(Bounds, compositeRenderTexture, new Rect(0, 0, compositeRenderTexture.width, compositeRenderTexture.height), dp);
            }
            else
            {
                if (hasBackgroundChildren)
                {
                    SmartUI.BeginGroup(Bounds, false);
                    DrawChildren(-1);
                    SmartUI.EndGroup();
                }

                base.Draw();
            }
        }
예제 #18
0
파일: XImage.cs 프로젝트: valsavva/dynacat
		public override void Draw(DrawParameters p)
		{
			if (this.PropState.ScreenBounds.HasValue)
			{
				this.tmpBounds = this.PropState.ScreenBounds.Value;
				if (GameEngine.Instance.Scale2D != Vector2.One)
				{
					var bounds = this.PropState.ScreenBounds.Value;
					bounds.Width += 1;
					bounds.Height += 1;
					this.PropState.ScreenBounds = bounds;
				}

				// first resolve the actual way we want to draw the image
				XImageStretchMode actualStretchMode = this.StretchMode;

				if (actualStretchMode == XImageStretchMode.Auto)
				{
					if ((this.Bounds.X != 0 || this.Bounds.Y != 0) && this.Bounds.Width == 0 && this.Bounds.Height == 0)
						actualStretchMode = XImageStretchMode.ActualSize;
					else
						actualStretchMode = XImageStretchMode.Stretch;
				}

				// draw it
				if (actualStretchMode == XImageStretchMode.ActualSize)
					DrawActualSize(p);
				else if (actualStretchMode == XImageStretchMode.Stretch)
					DrawStretched(p);
				else
					DrawTiles(p);

				this.PropState.ScreenBounds = this.tmpBounds;
			}
			base.Draw(p);
		}
예제 #19
0
 public static void PushParams(Color color, float duration)
 {
     parameterStack.Push(activeParameters);
     activeParameters = new DrawParameters(color, duration, true);
 }
예제 #20
0
            }//ctor ObjectCodeLine

            public ObjectCodeLine(DrawParameters drawParameters, uint address, string op, string operands, CodeViewTab parent)
                : base(drawParameters, String.Format("    {0,-6} {1}", op, operands), address, parent)
            {
            } //ctor ObjectCodeLine
예제 #21
0
 public ObjectCodeLine(DrawParameters drawParameters, uint address, uint hexContents, string contents, CodeViewTab parent)
     : base(drawParameters, contents, address, hexContents.ToString("X8"), parent)
 {
 }//ctor ObjectCodeLine
예제 #22
0
파일: XImage.cs 프로젝트: valsavva/dynacat
		void DrawActualSize(DrawParameters p)
		{
			// we're using location
			this.tmpVector1.X = this.PropState.ScreenBounds.Value.X;
			this.tmpVector1.Y = this.PropState.ScreenBounds.Value.Y;
			
			p.SpriteBatch.Draw(this.texture.Image, this.tmpVector1, this.SourceRectangle, actualBackColor, (float)screenRotation, this.Origin, this.PropState.Scale, (SpriteEffects)this.FlipEffects, this.PropState.Depth + p.NextSystemImageDepth());
		}
예제 #23
0
            }//ctor lstLine

            public ListLine(DrawParameters drawParameters, string text, string hexContents, CodeViewTab parent)
                : base(drawParameters, text, parent)
            {
                this.hexContents = hexContents;
                addressValid     = false;
            }//ctor lstLine for ARM instruction
예제 #24
0
 public ListLine(DrawParameters drawParameters, string text, uint address, CodeViewTab parent)
     : base(drawParameters, text, parent)
 {
     Address      = address;
     addressValid = true;
 }//ctor lstLine
예제 #25
0
            private string hexContents = null; // hex contents of line

            public ListLine(DrawParameters drawParameters, string text, CodeViewTab parent)
                : base(drawParameters, text, parent)
            {
            }
예제 #26
0
 //private readonly int col;
 public ErrorMsgLine(DrawParameters drawParameters, string errorMsg, CodeViewTab parent)
     : base(drawParameters, errorMsg, parent)
 {
     //this.col = col;
 }
예제 #27
0
 public static void PushParams(Color color, float duration, bool depthTest)
 {
     parameterStack.Push(activeParameters);
     activeParameters = new DrawParameters(color, duration, depthTest);
 }
예제 #28
0
파일: XImage.cs 프로젝트: valsavva/dynacat
		void DrawStretched(DrawParameters p)
		{
			p.SpriteBatch.Draw(this.texture.Image, this.PropState.ScreenBounds.Value, this.SourceRectangle, actualBackColor, screenRotation, this.Origin, (SpriteEffects)this.FlipEffects, this.PropState.Depth + p.NextSystemImageDepth());
		}
예제 #29
0
    /**
     * Draws a texture with given parameter
     *
     * @param uvFrame frame for UVs in texels.
     */
    private static void DrawMaster(Rect screenRect, Texture texture, Rect uvFrame, DrawParameters dp, RectOffset origionalBorder = null)
    {
        //3ms for these 4 lines
        if (!isRepaint)
        {
            return;
        }
        if (texture == null)
        {
            return;
        }
        if (!dp.IsVisibile(texture))
        {
            return;
        }
        if (dp.Scale.x * dp.Scale.y == 0)
        {
            return;
        }

        screenRect.width  *= dp.Scale.x;
        screenRect.height *= dp.Scale.y;

        Material material = dp.GetPreparedMaterial(texture);

        // --------------------------------------
        // Transform and clip.

        Vector4 clipping = Vector4.zero;

        Rect transformedRect = TransformTheRect(screenRect);
        Rect clippedRect     = transformedRect;
        Rect sourceRect      = new Rect(uvFrame);

        int borderLeft   = origionalBorder == null ? 0 : origionalBorder.left;
        int borderRight  = origionalBorder == null ? 0 : origionalBorder.right;
        int borderTop    = origionalBorder == null ? 0 : origionalBorder.top;
        int borderBottom = origionalBorder == null ? 0 : origionalBorder.bottom;

        // No clipping for rotated sprites yet.
        bool disableClip = dp.Rotation != 0;

        if (!disableClip)
        {
            clippedRect = ClipTheRect(transformedRect, ref clipping);
            bool hasClipped = (clipping != Vector4.zero);

            //stub:

            /*
             * if (hasClipped) {
             *      SmartUI.Color = Color.red;
             *      if (screenRect.Contains(new Vector2(InputEx.mousePosition.x, InputEx.mousePosition.y)))
             *              Trace.LogDebug("Clipped {0} to {1}", transformedRect, clippedRect);
             * } else
             *      SmartUI.Color = Color.green;
             */

            if ((clippedRect.width <= 0) || (clippedRect.height <= 0))
            {
                return;
            }

            if (hasClipped)
            {
                // Calculate clipped UVs.
                sourceRect     = new Rect();
                sourceRect.min = PixelToUV(transformedRect, uvFrame, clippedRect.min, origionalBorder);
                sourceRect.max = PixelToUV(transformedRect, uvFrame, clippedRect.max, origionalBorder);

                // Upside down swap.  This has something todo with the fact that the screen has (0,0) at the top left
                // and the texture has (0,0) at the bottom left.
                float newMin = uvFrame.yMin + (uvFrame.yMax - sourceRect.yMax);
                float newMax = uvFrame.yMax + (uvFrame.yMin - sourceRect.yMin);
                sourceRect.yMin = newMin;
                sourceRect.yMax = newMax;


                // Adjust border for clipping.
                if (origionalBorder != null)
                {
                    clipping[0] /= dp.Scale.x;
                    clipping[2] /= dp.Scale.x;
                    clipping[1] /= dp.Scale.y;
                    clipping[3] /= dp.Scale.y;

                    borderLeft  = Util.ClampInt(borderLeft - (int)clipping[0], 0, int.MaxValue);
                    borderRight = Util.ClampInt(borderRight - (int)clipping[2], 0, int.MaxValue);

                    borderTop    = Util.ClampInt(borderTop - (int)clipping[1], 0, int.MaxValue);
                    borderBottom = Util.ClampInt(borderBottom - (int)clipping[3], 0, int.MaxValue);
                }
            }
        }

        // Convert source rect to normalised.
        sourceRect.xMin *= texture.texelSize.x;
        sourceRect.xMax *= texture.texelSize.x;
        sourceRect.yMin *= texture.texelSize.y;
        sourceRect.yMax *= texture.texelSize.y;

        // Work out the best way to draw this.
        DrawMethod drawMethod = DrawMethod.Standard;

        if (origionalBorder != null)
        {
            drawMethod = DrawMethod.Bordered;
        }

        if ((origionalBorder != null) && (texture.HighDPI()))
        {
            drawMethod = DrawMethod.Native;
        }

        if (ShowGuiMaterial && !dp.IsDebugDraw)
        {
            drawMethod = DrawMethod.DebugColor;
        }

        // Apply rotation
        if (dp.Rotation != 0)
        {
            Engine.PushGUI();
            var rotationMatrix =
                Extentions.GetTranslationMatrix(clippedRect.center.x, clippedRect.center.y, 0) *
                Extentions.GetRotationMatrix(0, 0, dp.Rotation) *
                Extentions.GetTranslationMatrix(-clippedRect.center.x, -clippedRect.center.y, 0);

            GUI.matrix *= rotationMatrix;
        }

        // Draw the thing.
        switch (drawMethod)
        {
        case DrawMethod.DebugColor:
            Color = dp.DebugColor;
            DrawMaster(screenRect, StockTexture.White, new Rect(0, 0, 2, 2), DrawParameters.DebugDraw);
            break;

        case DrawMethod.Standard:
            Graphics.DrawTexture(clippedRect, texture, sourceRect, 0, 0, 0, 0, SmartUI.Color, material);
            break;

        case DrawMethod.Bordered:
            Graphics.DrawTexture(clippedRect, texture, sourceRect, borderLeft, borderRight, borderTop, borderBottom, SmartUI.Color, material);
            break;

        // The native draw will reverse the DPI scaling on the Gui matrix and then draw the object at an adjusted size.
        // This allows things like bordered gui objects to display correctly without distortion.

        case DrawMethod.Native:
            const float scale = 2;
            Engine.PushGUI();
            GUI.matrix *= Matrix4x4.Scale(Vector3.one / scale);
            clippedRect = clippedRect.Scaled(scale);
            Graphics.DrawTexture(clippedRect, texture, sourceRect, (int)(borderLeft * scale), (int)(borderRight * scale), (int)(borderTop * scale), (int)(borderBottom * scale), SmartUI.Color, material);
            Engine.PopGUI();
            break;
        }

        if (ShowGuiBounds && !dp.IsDebugDraw)
        {
            Color = Color.red;
            DrawMaster(screenRect, StockTexture.SimpleRect, new Rect(0, 0, 4, 4), DrawParameters.DebugDraw, BORDER_2PX);
        }

        if (dp.Rotation != 0)
        {
            Engine.PopGUI();
        }

        Color = Color.white;
    }
예제 #30
0
    // -----------------------------------------
    // texture drawing routines
    // -----------------------------------------

    public static void Draw(Rect screenRect, Texture texture, Rect uvFrame, DrawParameters dp)
    {
        DrawMaster(screenRect, texture, uvFrame, dp);
    }
예제 #31
0
파일: XImage.cs 프로젝트: valsavva/dynacat
		void DrawTiles(DrawParameters p)
		{
			var depth = this.PropState.Depth + p.NextSystemImageDepth();
			var imageRes = this.texture.Image.Bounds;
			Rectangle screenBounds = Rectangle.Empty;
			this.PropState.ScreenBounds.Value.ToRectangle(ref screenBounds);

			// fill whole rows and cols first
			int wholeCols = screenBounds.Width / imageRes.Width;
			int wholeRows = screenBounds.Height / imageRes.Height;

			Vector2 loc = new Vector2(screenBounds.X, screenBounds.Y);

            Rectangle? srcRect = null;
            this.SourceRectangle.ToRectangle(ref srcRect);

			for(int row = 0; row < wholeRows; row++)
			{
				loc.X = screenBounds.X;
				for(int col = 0; col < wholeCols; col++)
				{
					p.SpriteBatch.Draw(this.texture.Image, loc, srcRect, actualBackColor, 0f, Vector2.Zero, 1f, SpriteEffects.None, depth);
					loc.X += imageRes.Width;
				}
				loc.Y += imageRes.Height;
			}


            // fill margins
            int rightMargin = screenBounds.Width % imageRes.Width;
            int bottomMargin = screenBounds.Height % imageRes.Height;
            Rectangle sourceBounds = imageRes;

            if (rightMargin != 0)
            {
                loc.X = screenBounds.X + wholeCols * imageRes.Width;
                loc.Y = screenBounds.Y;

                sourceBounds.Width = rightMargin;

                for (int row = 0; row < wholeRows; row++)
                {
                    p.SpriteBatch.Draw(this.texture.Image, loc, sourceBounds, actualBackColor, 0f, Vector2.Zero, 1f, SpriteEffects.None, depth);
                    loc.Y += imageRes.Height;
                }


                if (bottomMargin != 0)
                {
                    sourceBounds.Height = bottomMargin;
                    p.SpriteBatch.Draw(this.texture.Image, loc, sourceBounds, actualBackColor, 0f, Vector2.Zero, 1f, SpriteEffects.None, depth);
                }
            }


            if (bottomMargin != 0)
            {
                loc.X = screenBounds.X;

                sourceBounds.Width = imageRes.Width;

                for (int col = 0; col < wholeCols; col++)
                {
                    p.SpriteBatch.Draw(this.texture.Image, loc, sourceBounds, actualBackColor, 0f, Vector2.Zero, 1f, SpriteEffects.None, depth);
                    loc.X += imageRes.Width;
                }
            }

        }
예제 #32
0
 public static void Draw(Rect screenRect, Sprite sprite, DrawParameters dp)
 {
     DrawMaster(screenRect, sprite.texture, sprite.rect, dp);
 }
예제 #33
0
 protected CodeViewLine(DrawParameters drawParameters, string text, CodeViewTab parent)
 {
     _drawParameters = drawParameters;
     Text            = text;
     _parent         = parent;
 }
예제 #34
0
 public ErrorLine(DrawParameters drawParameters, string text, int line, CodeViewTab parent)
     :
     base(drawParameters, text, parent)
 {
     mLine = line;
 }
예제 #35
0
 public static void Draw(float x, float y, Sprite sprite, DrawParameters dp)
 {
     Draw(new Rect(x, y, sprite.rect.width, sprite.rect.height), sprite, dp);
 }