simple trending widget

diff --git a/Crow.csproj b/Crow.csproj
index fbb6ca242a161c08831bdfc17854ee069f2081e2..5d2ad868ff5a988f2aad71fa7ea057c56b75c5a2 100644 (file)
--- a/Crow.csproj
+++ b/Crow.csproj
@@ -133,6 +133,7 @@
     <Compile Include="src\Fill\Fill.cs" />
     <Compile Include="src\LayoutingEventArgs.cs" />
     <Compile Include="src\ScrollingEventArgs.cs" />
+    <Compile Include="src\GraphicObjects\Trend.cs" />
   </ItemGroup>
   <ItemGroup>
     <Reference Include="System" />

diff --git a/src/GraphicObjects/Trend.cs b/src/GraphicObjects/Trend.cs
index ffc25c39e3ae79d7740aca7bbe893a2f821b57fa..7f12b675da4df9f298c803357f4ea010374d3ac1 100644 (file)
--- a/src/GraphicObjects/Trend.cs
+++ b/src/GraphicObjects/Trend.cs
@@ -19,13 +19,163 @@
 //  You should have received a copy of the GNU General Public License
 //  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 using System;
+using System.Collections.Generic;
+using System.Xml.Serialization;
+using System.ComponentModel;
 
 namespace Crow
 {
-       public class Trend
+       public class Trend : GraphicObject
        {
+               #region private fields
+               double minValue, maxValue, lowThreshold, highThreshold;
+               Fill lowThresholdFill, highThresholdFill;
+               int nbValues;
+               List<double> values = new List<double>();
+               #endregion
+
+
+
+               public virtual void AddValue(double _value)
+               {
+                       values.Add (_value);
+                       while (values.Count > nbValues)
+                               values.RemoveAt (0);
+                       registerForGraphicUpdate ();
+               }
+
                public Trend ()
                {
                }
+               [XmlIgnore]public virtual int NewValue {
+                       set {
+                               AddValue (value);
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue(100)]
+               public virtual int NbValue {
+                       get { return nbValues; }
+                       set {
+                               if (nbValues == value)
+                                       return;
+
+                               nbValues = value;
+                               NotifyValueChanged ("NbValues", minValue);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue(0.0)]
+               public virtual double Minimum {
+                       get { return minValue; }
+                       set {
+                               if (minValue == value)
+                                       return;
+
+                               minValue = value;
+                               NotifyValueChanged ("Minimum", minValue);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue(100.0)]
+               public virtual double Maximum
+               {
+                       get { return maxValue; }
+                       set {
+                               if (maxValue == value)
+                                       return;
+
+                               maxValue = value;
+                               NotifyValueChanged ("Maximum", maxValue);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue(20.0)]
+               public virtual double LowThreshold {
+                       get { return lowThreshold; }
+                       set {
+                               if (lowThreshold == value)
+                                       return;
+                               lowThreshold = value;
+                               NotifyValueChanged ("LowThreshold", lowThreshold);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue(80.0)]
+               public virtual double HighThreshold {
+                       get { return highThreshold; }
+                       set {
+                               if (highThreshold == value)
+                                       return;
+                               highThreshold = value;
+                               NotifyValueChanged ("HighThreshold", highThreshold);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue("DarkRed")]
+               public virtual Fill LowThresholdFill {
+                       get { return lowThresholdFill; }
+                       set {
+                               if (lowThresholdFill == value)
+                                       return;
+                               lowThresholdFill = value;
+                               NotifyValueChanged ("LowThresholdFill", lowThresholdFill);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               [XmlAttributeAttribute()][DefaultValue("DarkGreen")]
+               public virtual Fill HighThresholdFill {
+                       get { return highThresholdFill; }
+                       set {
+                               if (highThresholdFill == value)
+                                       return;
+                               highThresholdFill = value;
+                               NotifyValueChanged ("HighThresholdFill", highThresholdFill);
+                               registerForGraphicUpdate ();
+                       }
+               }
+               protected override void onDraw (Cairo.Context gr)
+               {
+                       base.onDraw (gr);
+
+                       if (values.Count == 0)
+                               return;
+                       Rectangle r = ClientRectangle;
+
+                       int i = values.Count -1;
+
+                       double ptrX = (double)r.Right;
+                       double scaleY = (double)r.Height / (Maximum - Minimum);
+                       double stepX = (double)r.Width / (double)nbValues;
+
+                       gr.LineWidth = 1.0;
+                       gr.SetDash (new double[]{ 1.0 },0.0);
+
+
+
+                       LowThresholdFill.SetAsSource (gr);
+                       gr.MoveTo (r.Left, r.Bottom - LowThreshold * scaleY);
+                       gr.LineTo (r.Right, r.Bottom - LowThreshold * scaleY);
+//                     gr.Rectangle (r.Left, r.Bottom - LowThreshold * scaleY, r.Width, LowThreshold * scaleY);
+                       gr.Stroke();
+
+                       HighThresholdFill.SetAsSource (gr);
+                       gr.MoveTo (r.Left, (Maximum - HighThreshold) * scaleY);
+                       gr.LineTo (r.Right, (Maximum - HighThreshold) * scaleY);
+//                     gr.Rectangle (r.Left, r.Top, r.Width, (Maximum - HighThreshold) * scaleY);
+                       gr.Stroke();
+
+                       gr.MoveTo (ptrX, values [i] * scaleY);
+
+                       Foreground.SetAsSource (gr);
+                       gr.SetDash (new double[]{ }, 0.0);
+
+                       while (i >= 0) {
+                                       gr.LineTo (ptrX, r.Bottom - values [i] * scaleY);
+                               ptrX -= stepX;
+                               i--;
+                       }
+                       gr.Stroke ();
+               }
        }
 }
+