protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (String.IsNullOrEmpty(Increment))
{
return;
}
double increment = ConvertIncrementStringToDouble(Increment, propertyType);
// Find integer factors from the minimum and maximum values
int minFactor = (int)Math.Floor(minValue / increment);
int maxFactor = (int)Math.Ceiling(maxValue / increment);
// Try to avoid division by zero, please
if (minFactor == maxFactor)
{
minFactor--;
maxFactor++;
}
// Gaps between the ticks
double tickLength = Length / (maxFactor - minFactor);
// Calculate AxisItem objects and add to collection
for (int factor = minFactor; factor <= maxFactor; factor++)
{
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(factor * increment, propertyType),
Offset = (factor - minFactor) * tickLength
};
if (IsFlipped)
{
axisItem.Offset = Length - axisItem.Offset;
}
AxisItems.Add(axisItem);
}
// Calculate new minimums and maximums
minValue = increment * minFactor;
maxValue = increment * maxFactor;
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
for (int index = 0; index < Parent.ItemsSource.Count; index++)
{
object item = Parent.ItemsSource[index];
double value = GetItemPropertyValue(item, PropertyName);
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(value, propertyType),
Offset = Length * (value - minValue) / (maxValue - minValue)
};
if (IsFlipped)
axisItem.Offset = Length - axisItem.Offset;
AxisItems.Add(axisItem);
}
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (String.IsNullOrEmpty(Increment))
{
return;
}
double increment = ConvertIncrementStringToDouble(Increment, propertyType);
// Find integer factors from the minimum and maximum values
int minFactor = (int)Math.Floor(minValue / increment);
int maxFactor = (int)Math.Ceiling(maxValue / increment);
// Try to avoid division by zero, please
if (minFactor == maxFactor)
{
minFactor--;
maxFactor++;
}
// Gaps between the ticks
double tickLength = Length / (maxFactor - minFactor);
// Calculate AxisItem objects and add to collection
for (int factor = minFactor; factor <= maxFactor; factor++)
{
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(factor * increment, propertyType),
Offset = (factor - minFactor) * tickLength
};
if (IsFlipped)
axisItem.Offset = Length - axisItem.Offset;
AxisItems.Add(axisItem);
}
// Calculate new minimums and maximums
minValue = increment * minFactor;
maxValue = increment * maxFactor;
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
for (int index = 0; index < Parent.ItemsSource.Count; index++)
{
object item = Parent.ItemsSource[index];
double value = GetItemPropertyValue(item, PropertyName);
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(value, propertyType),
Offset = Length * (value - minValue) / (maxValue - minValue)
};
if (IsFlipped)
{
axisItem.Offset = Length - axisItem.Offset;
}
AxisItems.Add(axisItem);
}
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (propertyType == typeof(DateTime))
throw new NotImplementedException("AdaptableIncrementAxis is not supported for DateTime." +
"Use AdaptableDateTimeAxis instead.");
if (Increments == null || Increments.Count == 0)
throw new ArgumentException("Increments collection must contain have at least one item");
if (MaximumItems < 2)
throw new ArgumentException("MaximumItems must be at least 2");
if (minValue == maxValue)
{
minValue -= 1;
maxValue += 1;
}
// Copy the increments to an array and sort them
double[] increments = new double[Increments.Count];
Increments.CopyTo(increments, 0);
Array.Sort(increments);
// Initialize IncrementFinder
IncrementFinder finder = new IncrementFinder(increments, minValue, maxValue);
// Try to find the optimum increment
while (true)
{
double increment = finder.Increment;
if (finder.TickCount == MaximumItems)
break;
else if (finder.TickCount > MaximumItems)
{
finder.BumpUp();
if (finder.TickCount <= MaximumItems)
break;
}
else if (finder.TickCount < MaximumItems)
{
finder.KickDown();
if (finder.TickCount > MaximumItems)
{
finder.BumpUp();
break;
}
}
}
// Now we're ready to find the axis items
double tickLength = Length / (finder.MaxFactor - finder.MinFactor);
// Calculate AxisItem objects and add to collection
for (int factor = finder.MinFactor; factor <= finder.MaxFactor; factor++)
{
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(factor * finder.Increment, propertyType),
Offset = (factor - finder.MinFactor) * tickLength
};
if (IsFlipped)
axisItem.Offset = Length - axisItem.Offset;
AxisItems.Add(axisItem);
}
// New minValue and maxValue for return
minValue = finder.Increment * finder.MinFactor;
maxValue = finder.Increment * finder.MaxFactor;
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (propertyType != typeof(DateTime))
throw new NotImplementedException("AdaptableDateTimeAxis is only for a DateTime axis.");
TestIncrementCollection(SecondIncrements, "Year");
TestIncrementCollection(MinuteIncrements, "Minute");
TestIncrementCollection(HourIncrements, "Hour");
TestIncrementCollection(DayIncrements, "Day");
TestIncrementCollection(MonthIncrements, "Month");
TestIncrementCollection(YearIncrements, "Year");
if (MaximumItems < 2)
throw new ArgumentException("MaximumItems must be at least 2");
if (minValue == maxValue)
{
minValue -= ConvertToDouble(TimeSpan.FromSeconds(1));
maxValue += ConvertToDouble(TimeSpan.FromSeconds(1));
}
DateTime minDateTime = (DateTime)ConvertFromDouble(minValue, propertyType);
DateTime maxDateTime = (DateTime)ConvertFromDouble(maxValue, propertyType);
Int32Collection[] incrementsArray = { SecondIncrements, MinuteIncrements, HourIncrements,
DayIncrements, MonthIncrements, YearIncrements };
int incrementsIndex = 0;
int incrementMultiplier = 1;
DateTimeInterval interval = DateTimeInterval.Second;
while (true)
{
Int32Collection increments = incrementsArray[(int)interval];
int increment = incrementMultiplier * increments[incrementsIndex];
DateTime minAxisDateTime = DateTimeFloor(minDateTime, interval, increment);
DateTime maxAxisDateTime = DateTimeCeiling(maxDateTime, interval, increment);
DateTime dtTick = minAxisDateTime;
int count = 1;
while (true)
{
dtTick = AddIncrement(dtTick, interval, increment);
count++;
if (dtTick >= maxAxisDateTime)
break;
if (count > MaximumItems)
break;
}
if (count <= MaximumItems)
{
minValue = ConvertToDouble(minAxisDateTime);
maxValue = ConvertToDouble(maxAxisDateTime);
dtTick = minAxisDateTime;
for (int i = 0; i < count; i++)
{
AxisItem axisItem = new AxisItem()
{
Item = dtTick,
Offset = Length * (ConvertToDouble(dtTick) - minValue) / (maxValue - minValue)
};
AxisItems.Add(axisItem);
dtTick = AddIncrement(dtTick, interval, increment);
}
DateTimeInterval = interval;
break;
}
if (incrementsIndex < increments.Count - 1)
{
incrementsIndex++;
}
else
{
incrementsIndex = 0;
if (interval != DateTimeInterval.Year)
interval++;
else
incrementMultiplier *= 10;
}
}
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (propertyType != typeof(DateTime))
{
throw new NotImplementedException("AdaptableDateTimeAxis is only for a DateTime axis.");
}
TestIncrementCollection(SecondIncrements, "Year");
TestIncrementCollection(MinuteIncrements, "Minute");
TestIncrementCollection(HourIncrements, "Hour");
TestIncrementCollection(DayIncrements, "Day");
TestIncrementCollection(MonthIncrements, "Month");
TestIncrementCollection(YearIncrements, "Year");
if (MaximumItems < 2)
{
throw new ArgumentException("MaximumItems must be at least 2");
}
if (minValue == maxValue)
{
minValue -= ConvertToDouble(TimeSpan.FromSeconds(1));
maxValue += ConvertToDouble(TimeSpan.FromSeconds(1));
}
DateTime minDateTime = (DateTime)ConvertFromDouble(minValue, propertyType);
DateTime maxDateTime = (DateTime)ConvertFromDouble(maxValue, propertyType);
Int32Collection[] incrementsArray = { SecondIncrements, MinuteIncrements, HourIncrements,
DayIncrements, MonthIncrements, YearIncrements };
int incrementsIndex = 0;
int incrementMultiplier = 1;
DateTimeInterval interval = DateTimeInterval.Second;
while (true)
{
Int32Collection increments = incrementsArray[(int)interval];
int increment = incrementMultiplier * increments[incrementsIndex];
DateTime minAxisDateTime = DateTimeFloor(minDateTime, interval, increment);
DateTime maxAxisDateTime = DateTimeCeiling(maxDateTime, interval, increment);
DateTime dtTick = minAxisDateTime;
int count = 1;
while (true)
{
dtTick = AddIncrement(dtTick, interval, increment);
count++;
if (dtTick >= maxAxisDateTime)
{
break;
}
if (count > MaximumItems)
{
break;
}
}
if (count <= MaximumItems)
{
minValue = ConvertToDouble(minAxisDateTime);
maxValue = ConvertToDouble(maxAxisDateTime);
dtTick = minAxisDateTime;
for (int i = 0; i < count; i++)
{
AxisItem axisItem = new AxisItem()
{
Item = dtTick,
Offset = Length * (ConvertToDouble(dtTick) - minValue) / (maxValue - minValue)
};
AxisItems.Add(axisItem);
dtTick = AddIncrement(dtTick, interval, increment);
}
DateTimeInterval = interval;
break;
}
if (incrementsIndex < increments.Count - 1)
{
incrementsIndex++;
}
else
{
incrementsIndex = 0;
if (interval != DateTimeInterval.Year)
{
interval++;
}
else
{
incrementMultiplier *= 10;
}
}
}
}
protected override void CalculateAxisItems(Type propertyType, ref double minValue, ref double maxValue)
{
if (propertyType == typeof(DateTime))
{
throw new NotImplementedException("AdaptableIncrementAxis is not supported for DateTime." +
"Use AdaptableDateTimeAxis instead.");
}
if (Increments == null || Increments.Count == 0)
{
throw new ArgumentException("Increments collection must contain have at least one item");
}
if (MaximumItems < 2)
{
throw new ArgumentException("MaximumItems must be at least 2");
}
if (minValue == maxValue)
{
minValue -= 1;
maxValue += 1;
}
// Copy the increments to an array and sort them
double[] increments = new double[Increments.Count];
Increments.CopyTo(increments, 0);
Array.Sort(increments);
// Initialize IncrementFinder
IncrementFinder finder = new IncrementFinder(increments, minValue, maxValue);
// Try to find the optimum increment
while (true)
{
double increment = finder.Increment;
if (finder.TickCount == MaximumItems)
{
break;
}
else if (finder.TickCount > MaximumItems)
{
finder.BumpUp();
if (finder.TickCount <= MaximumItems)
{
break;
}
}
else if (finder.TickCount < MaximumItems)
{
finder.KickDown();
if (finder.TickCount > MaximumItems)
{
finder.BumpUp();
break;
}
}
}
// Now we're ready to find the axis items
double tickLength = Length / (finder.MaxFactor - finder.MinFactor);
// Calculate AxisItem objects and add to collection
for (int factor = finder.MinFactor; factor <= finder.MaxFactor; factor++)
{
AxisItem axisItem = new AxisItem()
{
Item = ConvertFromDouble(factor * finder.Increment, propertyType),
Offset = (factor - finder.MinFactor) * tickLength
};
if (IsFlipped)
{
axisItem.Offset = Length - axisItem.Offset;
}
AxisItems.Add(axisItem);
}
// New minValue and maxValue for return
minValue = finder.Increment * finder.MinFactor;
maxValue = finder.Increment * finder.MaxFactor;
}
