Thanks for your help. it's working!

Thanks!

I added public int Threshold to your Data class.

If value > Threshhld, i need to display Column Green.

Else i need to display column red.

See the code below:

---xaml file------

Window x:Class="ScatterAndColumn.MainWindow"

xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"

xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"

xmlns:local="clr-namespace:ScatterAndColumn"

Title="MainWindow" Height="350" Width="525" xmlns:ig="http://schemas.infragistics.com/xaml">

<Grid>

<ig:XamDataChart

Name="xamDataChart1">

<ig:XamDataChart.Resources>

<Style TargetType="Rectangle">

<Setter Property="local:StyleBinder.StyleBinderHelper">

<Setter.Value>

<local:StyleBinderHelper>

<local:StyleBinderHelper.Template>

<DataTemplate>

<local:RectangleColorChanger

YAxis="{Binding OuterContext.Series.YAxis}"

Value="{Binding Owner.ActualHeight}"

Threshold="{Binding Owner.Threshold}"

Rectangle="{Binding Owner}" />

</DataTemplate>

</local:StyleBinderHelper.Template>

</local:StyleBinderHelper>

</Setter.Value>

</Setter>

</Style>

</ig:XamDataChart.Resources>

<ig:XamDataChart.Axes>

<ig:NumericXAxis

x:Name="ScatterXAxis" />

<ig:NumericYAxis

x:Name="ScatterYAxis" />

<ig:CategoryXAxis

x:Name="CatXAXis"

ItemsSource="{Binding}"/>

</ig:XamDataChart.Axes>

<ig:XamDataChart.Series>

<ig:ColumnSeries

ItemsSource="{Binding}"

XAxis="{Binding ElementName=CatXAXis}"

YAxis="{Binding ElementName=ScatterYAxis}"

Tag="{Binding Path=Threshold}"

ValueMemberPath="Value"/>

<ig:ScatterSeries

ItemsSource="{Binding}"

XAxis="{Binding ElementName=ScatterXAxis}"

YAxis="{Binding ElementName=ScatterYAxis}"

MarkerType="Diamond" MarkerBrush="Black"

XMemberPath="Open"

YMemberPath="Close"/>

</ig:XamDataChart.Series>

</ig:XamDataChart>

</Grid>

</

Window>

---code behind----------

System;

System.Collections.Generic;

System.Linq;

System.Text;

System.Windows;

System.Windows.Controls;

System.Windows.Data;

System.Windows.Documents;

System.Windows.Input;

System.Windows.Media;

System.Windows.Media.Imaging;

System.Windows.Navigation;

System.Windows.Shapes;

System.ComponentModel;

System.Collections.ObjectModel;

ScatterAndColumn

{

/// <summary>

/// Interaction logic for MainWindow.xaml

/// </summary>

public partial class MainWindow : Window

public MainWindow()

{

InitializeComponent();

Data.GetData(10, 10, 100);

}

}

public class Data : INotifyPropertyChanged

private int open;

private int close;

private int high;

private int low;

private int value;

private string label;

private int threshold = 1;

public int Threshold

{

get { return Close; }

set

{

value;

PropChanged(

"Threshold");

}

}

public string Label

{

get { return label; }

set

value;

PropChanged(

"Label");

}

}

public int Open

{

get { return open; }

set

value;

PropChanged(

"Open");

}

}

public int Close

{

get { return close; }

set

value;

PropChanged(

"Close");

}

}

public int High

{

get { return high; }

set

value;

PropChanged(

"High");

}

}

public int Low

{

get { return low; }

set

value;

PropChanged(

"Low");

}

}

public int Value

{

get { return value; }

set

this.value = value;

PropChanged(

"Value");

}

}

public static ObservableCollection<Data> GetData(int points, int rangeStart, int rangeEnd)

{

ObservableCollection<Data> data = new ObservableCollection<Data>();

Random r = new Random();

for (int i = 0; i < points; i++)

{

new Data

//r.Next(rangeStart, rangeEnd),

return data;

}

public event PropertyChangedEventHandler PropertyChanged;

public void PropChanged(string name)

{

if (PropertyChanged != null)

PropertyChanged(

this, new PropertyChangedEventArgs(name));

}

}

}

using

System;

System.Collections.Generic;

System.Linq;

System.Text;

System.Windows;

Infragistics.Controls.Charts;

System.Windows.Media;

System.ComponentModel;

System.Windows.Data;

System.Windows.Shapes;

ScatterAndColumn

{

public static class StyleBinder

public static readonly DependencyProperty StyleBinderHelperProperty =

DependencyProperty.RegisterAttached(

"StyleBinderHelper",

typeof(StyleBinderHelper),

typeof(StyleBinder),

new PropertyMetadata(null,

(o, e) => StyleBinderHelperChanged(o, e)));

private static void StyleBinderHelperChanged(

DependencyObject o,

DependencyPropertyChangedEventArgs e)

{

FrameworkElement ele = o as FrameworkElement;

if (ele == null)

{

return;

}

BindingExpression be =

ele.GetBindingExpression

(

StyleBinder.StyleBinderContextProperty);

if (be == null)

{

ele.SetBinding(StyleBinderContextProperty,

new Binding());

}

if (e.NewValue != null)

{

StyleBinderHelper)e.NewValue).PushContent(ele);

}

}

public static void SetStyleBinderHelper(

DependencyObject target,

StyleBinderHelper value)

{

target.SetValue(StyleBinderHelperProperty, value);

}

public static StyleBinderHelper GetStyleBinderHelper(

DependencyObject target)

{

return (StyleBinderHelper)target.GetValue(StyleBinderHelperProperty);

}

public static readonly DependencyProperty StyleBinderContentProperty =

DependencyProperty.RegisterAttached(

"StyleBinderContent",

typeof(FrameworkElement),

typeof(StyleBinder),

new PropertyMetadata(null,

(o, e) => StyleBinderContentChanged(o, e)));

private static void StyleBinderContentChanged(

DependencyObject o,

DependencyPropertyChangedEventArgs e)

{

}

public static void SetStyleBinderContent(

DependencyObject target,

FrameworkElement value)

{

target.SetValue(StyleBinderContentProperty, value);

}

public static FrameworkElement GetStyleBinderContent(

DependencyObject target)

{

return (FrameworkElement)target.GetValue(StyleBinderContentProperty);

}

public static readonly DependencyProperty StyleBinderContextProperty =

DependencyProperty.RegisterAttached(

"StyleBinderContext",

typeof(object),

typeof(StyleBinder),

new PropertyMetadata(null,

(o, e) => StyleBinderContextChanged(o, e)));

private static void StyleBinderContextChanged(

DependencyObject o,

DependencyPropertyChangedEventArgs e)

{

FrameworkElement content =

StyleBinder.GetStyleBinderContent(o);

if (content != null)

{

new HelperContext()

{

OuterContext = e.NewValue,

as FrameworkElement

public static void SetStyleBinderContext(

DependencyObject target,

object value)

{

target.SetValue(StyleBinderContextProperty, value);

}

public static object GetStyleBinderContext(

DependencyObject target)

{

return target.GetValue(StyleBinderContextProperty);

}

}

public class StyleBinderHelper

FrameworkElement

internal void PushContent(FrameworkElement ele)

{

if (Template == null)

{

return;

}

FrameworkElement content = Template.LoadContent() as FrameworkElement;

if (content == null)

{

return;

}

new HelperContext()

{

StyleBinder.GetStyleBinderContext(ele),

Owner = ele

};

StyleBinder.SetStyleBinderContent(ele, content);

}

public DataTemplate Template { get; set; }

}

public class HelperContext

INotifyPropertyChanged

private object _outerContext;

public object OuterContext

{

get { return _outerContext; }

set

value;

RaisePropertyChanged(

"OuterContext");

}

}

private FrameworkElement _owner;

public FrameworkElement Owner

{

get { return _owner; }

set

value;

RaisePropertyChanged(

"Owner");

}

}

public event PropertyChangedEventHandler PropertyChanged;

private void RaisePropertyChanged(string propertyName)

{

if (PropertyChanged != null)

{

this,

new PropertyChangedEventArgs(propertyName));

}

}

}

public class RectangleColorChanger

FrameworkElement

public static readonly DependencyProperty ValueProperty =

DependencyProperty.Register(

"Value",

typeof(double),

typeof(RectangleColorChanger),

new PropertyMetadata(0.0, (o, e) => (o as RectangleColorChanger)

.ValueChanged(e)));

public double Value

{

get { return (double)GetValue(ValueProperty); }

set { SetValue(ValueProperty, value); }

}

public static readonly DependencyProperty ThresholdProperty =

DependencyProperty.Register(

"Threshold",

typeof(double),

typeof(RectangleColorChanger),

new PropertyMetadata(0.0, (o, e) => (o as RectangleColorChanger)

.ThresholdChanged(e)));

private void ThresholdChanged(

DependencyPropertyChangedEventArgs e)

{

UpdateColor();

}

public double Threshold

{

get { return (double)GetValue(ThresholdProperty); }

set { SetValue(ThresholdProperty, value); }

}

public static readonly DependencyProperty RectangleProperty =

DependencyProperty.Register(

"Rectangle",

typeof(Rectangle),

typeof(RectangleColorChanger),

new PropertyMetadata(null,

(o, e) => (o

as RectangleColorChanger)

.RectangleChanged(e)));

private void UpdateColor()

{

if (YAxis == null)

{

return;

}

if (Rectangle == null)

{

return;

}

Rect viewport = new Rect(0, 0, YAxis.ActualWidth, YAxis.ActualHeight);

double zero = YAxis.GetScaledValue(YAxis.ReferenceValue, YAxis.Chart.WindowRect, viewport);

double top = Rectangle.TransformToVisual(YAxis).Transform(new Point(0, 0)).Y;

double bottom = Rectangle.TransformToVisual(YAxis).Transform(new Point(0, Rectangle.Height)).Y;

double val = 0;

if (top < zero && bottom <= zero)

{

val = YAxis.GetUnscaledValue(top, YAxis.Chart.WindowRect, viewport);

}

else

if (val < Threshold)

{

new SolidColorBrush(Colors.Red);

}

else

new SolidColorBrush(Colors.Green);

}

}

private void RectangleChanged(DependencyPropertyChangedEventArgs e)

{

UpdateColor();

}

public Rectangle Rectangle

{

get { return (Rectangle)GetValue(RectangleProperty); }

set { SetValue(RectangleProperty, value); }

}

private void ValueChanged(DependencyPropertyChangedEventArgs e)

{

UpdateColor();

}

public static readonly DependencyProperty YAxisProperty =

DependencyProperty.Register(

"YAxis",

typeof(NumericYAxis),

typeof(RectangleColorChanger),

new PropertyMetadata(null, (o, e) => (o as RectangleColorChanger)

.YAxisChanged(e)));

private void YAxisChanged(

DependencyPropertyChangedEventArgs e)

{

UpdateColor();

}

public NumericYAxis YAxis

{

get { return (NumericYAxis)GetValue(YAxisProperty); }

set { SetValue(YAxisProperty, value); }

}

}

}