Sorry, it does work just fine.  I just needed to set a trigger to update the chart when a new data source was selected.  I didn't need to do this before, but the code works great.  Thanks for making a great product!

Also, does it matter if I use .net 4, 4.5, or 4.5.1 for this?  I know if I use 4.0 I would have to compile using the wpf 4.0 project, but is there any functional differences between 4 and 4.5 in oxyplot?

Hi,
   This worked for the version that was out when I posted this 3 years ago.  Going back to it, I haven't been able to successfully make this work.  I put in a customTwoColorLineSeries class in both the main series section and in the wpf series so I could use it in xaml.  It compiled fine but is not displaying data despite the code not really changing.  Any suggestions as to why this new class would fail.   It is just a line series where below a certain limit, the line is green.  Then it is a user defined color and a max limit is set when above that the line is red.  I'm really stuck on this and it is critical for software we use on a research vessel.  Thanks for all your hard work!

Here is the code from the main series class (sorry the formatting is off, I'm not sure how to post code here):
namespace OxyPlot.Series
{
using System.Collections.Generic;

/// <summary>
/// Represents a two-color line series.
/// </summary>
public class CustomTwoColorLineSeries : LineSeries
{
/// <summary>
/// Initializes a new instance of the <see cref = "CustomTwoColorLineSeries" /> class.
/// </summary>
public CustomTwoColorLineSeries()
{
this.MinLimit = 0.0;
this.MaxLimit = 0.0;
}

/// <summary>
/// Gets or sets the min limit.
/// </summary>
/// <remarks>
/// The parts of the line that is below this limit will be rendered with green.
/// </remarks>
public double MinLimit { get; set; }

/// <summary>
/// Gets or sets the max limit.
/// </summary>
/// <remarks>
/// The parts of the line that is above the limit will be rendered with red.
/// </remarks>
public double MaxLimit { get; set; }

/// <summary>
/// Sets the default values.
/// </summary>
/// <param name="model">The model.</param>
protected internal override void SetDefaultValues(PlotModel model)
{
base.SetDefaultValues(model);
}

/// <summary>
/// Renders the smoothed line.
/// </summary>
/// <param name="rc">The render context.</param>
/// <param name="clippingRect">The clipping rectangle.</param>
/// <param name="pointsToRender">The points.</param>
protected override void RenderLine(IRenderContext rc, OxyRect clippingRect, IList<ScreenPoint> pointsToRender)
{
double right = clippingRect.Right;
double left = clippingRect.Left;
double minX = this.XAxis.Transform(this.MinLimit);
double maxX = this.XAxis.Transform(this.MaxLimit);

if (minX < left)
{
minX = left;
}

if (minX > right)
{
minX = right;
}

if (maxX < left)
{
maxX = left;
}

if (maxX > right)
{
maxX = right;
}

if (maxX < minX)
{
maxX = minX;
}

clippingRect.Right = minX;

rc.DrawClippedLine(
clippingRect,
pointsToRender,
this.MinimumSegmentLength * this.MinimumSegmentLength,
OxyColors.Green,
this.StrokeThickness,
this.Dashes,
this.LineJoin,
false);

clippingRect.Left = minX;
clippingRect.Width = maxX - minX;
rc.DrawClippedLine(
clippingRect,
pointsToRender,
this.MinimumSegmentLength * this.MinimumSegmentLength,
this.Color,
this.StrokeThickness,
this.Dashes,
this.LineJoin,
false);

clippingRect.Left = maxX;
clippingRect.Width = right - maxX;
rc.DrawClippedLine(
clippingRect,
pointsToRender,
this.MinimumSegmentLength * this.MinimumSegmentLength,
OxyColors.Red,
this.StrokeThickness,
this.Dashes,
this.LineJoin,
false);
}
}
}


And the code from the wpf wrapper:
namespace OxyPlot.Wpf
{
using System.Windows;
using System.Windows.Media;

/// <summary>
/// The WPF wrapper for OxyPlot.CustomTwoColorLineSeries.
/// </summary>
public class CustomTwoColorLineSeries : LineSeries
{
/// <summary>
/// The min limit property.
/// </summary>
public static readonly DependencyProperty MinLimitProperty = DependencyProperty.Register(
"MinLimit", typeof(double), typeof(CustomTwoColorLineSeries), new UIPropertyMetadata(0.0, AppearanceChanged));

/// <summary>
/// The max limit property.
/// </summary>
public static readonly DependencyProperty MaxLimitProperty = DependencyProperty.Register(
"MaxLimit", typeof(double), typeof(CustomTwoColorLineSeries), new UIPropertyMetadata(0.0, AppearanceChanged));

/// <summary>
/// Initializes a new instance of the <see cref = "CustomTwoColorLineSeries" /> class.
/// </summary>
public CustomTwoColorLineSeries()
{
this.InternalSeries = new OxyPlot.Series.CustomTwoColorLineSeries();
}

/// <summary>
/// Gets or sets Min Limit.
/// </summary>
public double MinLimit
{
get
{
return (double)this.GetValue(MinLimitProperty);
}
set
{
this.SetValue(MinLimitProperty, value);
}
}

/// <summary>
/// Gets or sets Max Limit.
/// </summary>
public double MaxLimit
{
get
{
return (double)this.GetValue(MaxLimitProperty);
}
set
{
this.SetValue(MaxLimitProperty, value);
}
}

/// <summary>
/// Synchronizes the properties.
/// </summary>
/// <param name="series">The series.</param>
protected override void SynchronizeProperties(OxyPlot.Series.Series series)
{
base.SynchronizeProperties(series);
var s = series as OxyPlot.Series.CustomTwoColorLineSeries;
s.MinLimit = this.MinLimit;
s.MaxLimit = this.MaxLimit;
}
}
}