C:/Users/Andreas Schiffler/Desktop/SVN/NewGamePhysics/NewGamePhysics/GraphicalElements/ValueIndicator.cs

using System;
using System.Collections.Generic;
using System.Text;

using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;

using NewGamePhysics.StateManager;
using NewGamePhysics.Utilities;
using NewGamePhysics.GraphicalElements;

namespace NewGamePhysics.GraphicalElements
{
    public class ValueIndicator : GraphicalElementBase
    {
        private double value;

        private string format;

        private string valueAsString = String.Empty;

        private DateTime valueUpdate;

        private double minimumValue;

        private double maximumValue;

        private bool haveZero;

        private double lowValue;

        private double highValue;

        private Vector2 position;

        public const float Width = 200.0f;

        public const float Height = 40.0f;

        private string label;

        private Color drawColor;

        private bool lowHighColoring;

        private Color barColor;

        private Color[] barColors;

        private double updateInterval = 250.0;

        private Texture2D backgroundTexture;

        private Texture2D whiteTexture;

        private SpriteFont spriteFont;

        public ValueIndicator(
            ScreenManager manager,
            string label,
            string format)
            : this(manager, label, format, 0.0, 0.0)
        {
        }

        public ValueIndicator(
            ScreenManager manager, 
            string label, 
            string format,
            double minimum,
            double maximum) : base(manager)
        {
            // Store settings
            this.label = label;
            this.format = format;

            // Reset ranges
            this.minimumValue = minimum;
            this.maximumValue = maximum;
            double delta = 0.1 * (maximum - minimum);
            this.lowValue = minimum + delta;
            this.highValue = maximum - delta;

            // Update flag
            this.haveZero = ((this.minimumValue < 0.0) && (this.maximumValue > 0.0));

            // Default position and size
            this.position = new Vector2();

            // Color for numbers
            this.drawColor = new Color(180, 255, 180);

            // Bar indicator colors
            this.barColors = new Color[3];
            // red
            this.barColors[0] = new Color(255, 0, 0);
            // yellow
            this.barColors[1] = new Color(255, 255, 0);
            // green
            this.barColors[2] = new Color(0, 255, 0);

            // Guage backdrop texture
            this.backgroundTexture = ScreenManager.Game.Content.Load<Texture2D>(@"Sprites\value_gauge");

            // White indicator texture
            this.whiteTexture = TextureHelpers.Create(ScreenManager.GraphicsDevice, Color.White);

            // Now set a default value, set bar color.
            this.SetValue(0.0);

            // Label font
            this.spriteFont = ScreenManager.Fonts["small"];
        }

        #region properties

        public double MinimumValue
        {
            get
            {
                return this.minimumValue;
            }

            set
            {
                this.minimumValue = value;

                // Maybe also adjust low value
                if (this.lowValue < value)
                {
                    this.lowValue = value;
                }

                // Update flag
                this.haveZero = ((this.minimumValue < 0.0) && (this.maximumValue > 0.0));
            }
        }

        public double MaximumValue
        {
            get
            {
                return this.maximumValue;
            }

            set
            {
                this.maximumValue = value;

                // Maybe also adjust high value
                if (this.highValue > value)
                {
                    this.highValue = value;
                }

                // Update flag
                this.haveZero = ((this.minimumValue < 0.0) && (this.maximumValue > 0.0));
            }
        }

        public double LowValue
        {
            get { return this.lowValue; }

            set
            {
                if (value < this.minimumValue)
                {
                    throw new ArgumentOutOfRangeException("value");
                }

                this.lowValue = value;
            }
        }

        public double HighValue
        {
            get { return this.highValue; }

            set
            {
                if (value > this.maximumValue)
                {
                    throw new ArgumentOutOfRangeException("value");
                }

                this.highValue = value;
            }
        }

        public bool LowHighColoring
        {
            get { return this.lowHighColoring; }
            set { this.lowHighColoring = value; }
        }

        public double UpdateInterval
        {
            get { return this.updateInterval; }
            set { this.updateInterval = value; }
        }

        #endregion

        public void SetValue(double value)
        {
            // Recalculate min and max
            this.MinimumValue = Math.Min(this.minimumValue, Autorange.GetSnapValue(value, false));
            this.MaximumValue = Math.Max(this.maximumValue, Autorange.GetSnapValue(value, true));

            // Use 10% for low/high ranges
            double delta = 0.1 * (this.maximumValue - this.minimumValue);
            this.LowValue = this.minimumValue + delta;
            this.HighValue = this.maximumValue - delta;

            // Set value
            this.value = value;
            UpdateBarColor();
        }

        public void SetValueInRange(double value)
        {
            // Set value, but keep it in range
            if (value < minimumValue)
            {
                this.value = this.minimumValue;
            }
            else if (value > maximumValue)
            {
                this.value = this.maximumValue;
            }
            else
            {
                this.value = value;
            }

            UpdateBarColor();
        }

        public void SetMinimum(double value)
        {
            this.minimumValue = value;
        }

        public void SetMaximum(double value)
        {
            this.maximumValue = value;
        }

        public void SetPosition(Vector2 position)
        {
            this.position.X = position.X;
            this.position.Y = position.Y;
        }

        public void Draw(GameTime gameTime)
        {
            float outerHeight = Height;
            float innerHeightStep = 12.0f;
            float innerHeight = 3.0f * innerHeightStep;

            float outerWidth = Width;
            float innerWidth = Width - 4.0f;
            float rowOffsetX = 2.0f;
            float row1OffsetY = 2.0f;
            float row2OffsetY = 2.0f + innerHeightStep;
            float row3OffsetY = 2.0f + 2.0f*innerHeightStep;
            float rowHeight = 10.0f;
            float valueOffset = innerWidth * (float)((this.value - this.minimumValue) / (this.maximumValue - this.minimumValue));
            float zeroOffset = innerWidth * (float)((0.0 - this.minimumValue) / (this.maximumValue - this.minimumValue));

            Rectangle destination;

            // Prepare value string
            DateTime currentDate = DateTime.Now;
            TimeSpan elapsedSpan = new TimeSpan(currentDate.Ticks - valueUpdate.Ticks);
            if (elapsedSpan.TotalMilliseconds > this.updateInterval)
            {
                valueAsString = String.Format(
                    this.format,
                    this.value);
                valueUpdate = currentDate;
            }

            // Backdrop of gauge
            destination = new Rectangle((int)this.position.X, (int)this.position.Y, (int)outerWidth, (int)outerHeight);
            SpriteBatch.Begin();
            SpriteBatch.Draw(this.backgroundTexture, destination, Color.White);
            SpriteBatch.End();            

            // Row 1: value + unit
            Vector2 textSize = spriteFont.MeasureString(valueAsString);
            SpriteBatch.Begin();
            SpriteBatch.DrawString(
                spriteFont, 
                valueAsString,
                new Vector2(this.position.X + rowOffsetX, this.position.Y + row1OffsetY),
                this.drawColor, 0, new Vector2(), 1.0f,
                SpriteEffects.None, 0);
            SpriteBatch.End();

            // Row 2: Bar indicator
            if ((this.haveZero) && (valueOffset < zeroOffset))
            {
                destination = new Rectangle((int)(this.position.X + rowOffsetX + valueOffset), (int)(this.position.Y + row2OffsetY) + 1, (int)(zeroOffset - valueOffset), (int)rowHeight - 1);
            }
            else
            {
                destination = new Rectangle((int)(this.position.X + rowOffsetX + zeroOffset),  (int)(this.position.Y + row2OffsetY) + 1, (int)(valueOffset - zeroOffset), (int)rowHeight - 1);
            }
            SpriteBatch.Begin();
            SpriteBatch.Draw(this.whiteTexture, destination, this.barColor);
            SpriteBatch.End();

            // Lines
            PrimitiveBatch.Begin(PrimitiveType.LineList);
            Vector2 offset = new Vector2(rowOffsetX, row2OffsetY);

            // Zero
            if (this.haveZero)
            {
                Color lineColor = new Color(this.drawColor, 128);
                PrimitiveBatch.AddVertex(this.position + offset + new Vector2(zeroOffset, 0.0f), lineColor);
                PrimitiveBatch.AddVertex(this.position + offset + new Vector2(zeroOffset, rowHeight), lineColor);
            }

            // Value
            PrimitiveBatch.AddVertex(this.position + offset + new Vector2(valueOffset, 0.0f), this.drawColor);
            PrimitiveBatch.AddVertex(this.position + offset + new Vector2(valueOffset, rowHeight), this.drawColor);

            PrimitiveBatch.End();

            // Label
            if (!String.IsNullOrEmpty(this.label))
            {
                textSize = spriteFont.MeasureString(this.label);
                float textOffset = (innerWidth - textSize.X) * 0.5f;
                SpriteBatch.Begin();
                SpriteBatch.DrawString(
                    spriteFont,
                    this.label,
                    new Vector2(this.position.X + rowOffsetX + textOffset, this.position.Y + row3OffsetY),
                    Color.Black, 0, new Vector2(), 1.0f,
                    SpriteEffects.None, 0);
                SpriteBatch.End();
            }
        }

        private void UpdateBarColor()
        {
            if (this.lowHighColoring && 
                ((this.value == this.minimumValue) || (this.value == this.maximumValue)))
            {
                // red
                this.barColor = barColors[0];
            }
            else if (this.lowHighColoring && 
                ((this.value < this.lowValue) || (this.value > this.highValue)))
            {
                // yellow
                this.barColor = barColors[1];
            }
            else
            {
                // green
                this.barColor = barColors[2];
            }
        }
    }
}

---