void DeleteRangeButton_Click(object sender, RoutedEventArgs e)
{
if (ClassBreakConfigItems == null)
{
return;
}
ClassBreakConfigControl classBreakConfigControl = ClassBreakConfigItems.SelectedItem as ClassBreakConfigControl;
if (classBreakConfigControl == null || classBreakConfigControl.ClassBreak == null)
{
return;
}
if (ClassBreaksRenderer != null)
{
ClassBreaksRenderer.Classes.Remove(classBreakConfigControl.ClassBreak);
}
int prevIndex = ClassBreakConfigItems.SelectedIndex;
ClassBreakConfigItems.Items.Remove(classBreakConfigControl);
if (prevIndex > 0 && prevIndex <= ClassBreakConfigItems.Items.Count) // Remember .. we have a default symbol item at the top
{
ClassBreakConfigItems.SelectedIndex = prevIndex; // preserve selected item
}
}
private void bindList()
{
if (ClassBreakConfigItems != null)
{
if (ClassBreaksRenderer != null)
{
// Add the default symbol config control
DefaultSymbolConfigControl defaultSymbolConfigControl = new DefaultSymbolConfigControl()
{
Symbol = ClassBreaksRenderer.DefaultSymbol,
SymbolConfigProvider = SymbolConfigProvider,
GeometryType = GeometryType,
};
defaultSymbolConfigControl.DefaultSymbolModified += new EventHandler <SymbolSelectedEventArgs>(defaultSymbolConfigControl_DefaultSymbolModified);
ClassBreakConfigItems.Items.Add(defaultSymbolConfigControl);
ClassBreakConfigItems.SelectedItem = defaultSymbolConfigControl;
foreach (ClassBreakInfo classBreak in ClassBreaksRenderer.Classes)
{
ClassBreakConfigControl classBreakConfigControl = createNewClassBreakConfigControl(classBreak);
ClassBreakConfigItems.Items.Add(classBreakConfigControl);
}
}
}
}
private void updateSymbolConfigControlIfCurrentSelectedSymbol()
{
if (SymbolConfigControl == null || RendererSymbolSetContainerControl == null)
{
return;
}
ClassBreaksRendererSymbolsConfigControl symbolsConfigControl = RendererSymbolSetContainerControl.Content as ClassBreaksRendererSymbolsConfigControl;
if (symbolsConfigControl != null)
{
Control selectedControl = symbolsConfigControl.GetCurrentSelectedConfigControl();
ClassBreakConfigControl classBreaksConfigControl = selectedControl as ClassBreakConfigControl;
if (classBreaksConfigControl != null)
{
if (classBreaksConfigControl.ClassBreak != null)
{
SymbolConfigControl.Symbol = classBreaksConfigControl.ClassBreak.Symbol;
}
}
else
{
DefaultSymbolConfigControl defaultConfigControl = selectedControl as DefaultSymbolConfigControl;
if (defaultConfigControl != null)
{
SymbolConfigControl.Symbol = defaultConfigControl.Symbol;
}
}
}
else
{
UniqueValueRendererSymbolsConfigControl uniqueValueRendererConfigControl = RendererSymbolSetContainerControl.Content as UniqueValueRendererSymbolsConfigControl;
if (uniqueValueRendererConfigControl != null)
{
Control selectedControl = uniqueValueRendererConfigControl.GetCurrentSelectedConfigControl();
UniqueValueConfigControl uniqueValueConfigControl = selectedControl as UniqueValueConfigControl;
if (uniqueValueConfigControl != null)
{
if (uniqueValueConfigControl.UniqueValue != null)
{
SymbolConfigControl.Symbol = uniqueValueConfigControl.UniqueValue.Symbol;
}
}
else
{
DefaultSymbolConfigControl defaultConfigControl = selectedControl as DefaultSymbolConfigControl;
if (defaultConfigControl != null)
{
SymbolConfigControl.Symbol = defaultConfigControl.Symbol;
}
}
}
}
}
private ClassBreakConfigControl createNewClassBreakConfigControl(ClassBreakInfo classBreak)
{
ClassBreakConfigControl classBreakConfigControl = new ClassBreakConfigControl()
{
ClassBreak = classBreak,
SymbolConfigProvider = SymbolConfigProvider,
GeometryType = GeometryType,
};
classBreakConfigControl.ClassBreakModified += new EventHandler <ClassBreakModificationEventArgs>(classBreakConfigControl_ClassBreakChanged);
return(classBreakConfigControl);
}
void classBreakConfigControl_ClassBreakChanged(object sender, ClassBreakModificationEventArgs e)
{
if (e.ClassBreakModificationType == ClassBreakModificationType.SymbolChanged)
{
if (ClassBreakConfigItems != null)
{
ClassBreakConfigControl control = sender as ClassBreakConfigControl;
if (control != null && ClassBreakConfigItems.SelectedItem == control && control.ClassBreak != null)
{
if (SymbolConfigControl != null)
{
SymbolConfigControl.Symbol = control.ClassBreak.Symbol;
}
}
}
}
OnClassBreakRendererModified(EventArgs.Empty);
}
void AddRangeButton_Click(object sender, RoutedEventArgs e)
{
if (ClassBreaksRenderer == null)
{
return;
}
ClassBreakConfigControl classBreakConfigControl = null;
if (ClassBreaksRenderer.Classes.Count < 1) // Empty class break set
{
// Assign a first class break and symbolize it using the first class break
ClassBreakInfo newClassBreak = new ClassBreakInfo()
{
MinimumValue = 0,
MaximumValue = 0,
Symbol = ClassBreaksRenderer.DefaultSymbol != null?ClassBreaksRenderer.DefaultSymbol.CloneSymbol() : SymbolUtils.CreateDefaultSymbol(GeometryType),
};
classBreakConfigControl = createNewClassBreakConfigControl(newClassBreak);
ClassBreaksRenderer.Classes.Add(newClassBreak);
}
else
{
ClassBreakInfo lastClassBreak = ClassBreaksRenderer.Classes[ClassBreaksRenderer.Classes.Count - 1];
double currentMaxVal = lastClassBreak.MaximumValue;
lastClassBreak.MaximumValue -= Math.Floor((currentMaxVal - lastClassBreak.MinimumValue) / 2); // split class break into two
ClassBreakInfo newClassBreak = new ClassBreakInfo()
{
MinimumValue = lastClassBreak.MaximumValue + 1,
MaximumValue = currentMaxVal,
Symbol = lastClassBreak.Symbol != null?lastClassBreak.Symbol.CloneSymbol() : SymbolUtils.CreateDefaultSymbol(GeometryType),
};
classBreakConfigControl = createNewClassBreakConfigControl(newClassBreak);
ClassBreaksRenderer.Classes.Add(newClassBreak);
}
if (ClassBreakConfigItems != null)
{
ClassBreakConfigItems.Items.Add(classBreakConfigControl);
ClassBreakConfigItems.SelectedItem = classBreakConfigControl;
}
}
void ClassBreakConfigItems_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (ClassBreakConfigItems == null)
{
return;
}
ClassBreakConfigControl configControl = ClassBreakConfigItems.SelectedItem as ClassBreakConfigControl;
if (configControl != null)
{
OnCurrentClassBreakChanged(new CurrentClassBreakChangedEventArgs()
{
ClassBreak = configControl.ClassBreak,
});
return;
}
else
{
DefaultSymbolConfigControl defaultConfigControl = ClassBreakConfigItems.SelectedItem as DefaultSymbolConfigControl;
if (defaultConfigControl != null)
{
OnDefaultClassBreakBeingConfigured(new DefaultClassBreakBeingConfiguredEventArgs()
{
DefaultSymbol = defaultConfigControl.Symbol,
});
return;
}
}
if (ClassBreakConfigItems.Items != null)
{
foreach (Control control in ClassBreakConfigItems.Items)
{
ClassBreakConfigControl classBreakConfigItemControl = control as ClassBreakConfigControl;
if (classBreakConfigItemControl != null)
{
classBreakConfigItemControl.StopEditMode();
}
}
}
}
void MinTextBox_TextChanged(object sender, TextChangedEventArgs e)
{
if (ClassBreakConfigItems == null)
{
return;
}
ClassBreakConfigControl classBreakConfigControl = ClassBreakConfigItems.SelectedItem as ClassBreakConfigControl;
if (classBreakConfigControl == null || classBreakConfigControl.ClassBreak == null)
{
return;
}
double d;
if (double.TryParse(MinTextBox.Text, out d))
{
classBreakConfigControl.UpdateMinValue(d);
}
OnClassBreakRendererModified(EventArgs.Empty);
}
void ClassBreakConfigItems_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (ClassBreakConfigItems == null)
{
return;
}
// Enable disable previous/next buttons appropriately
if (PreviousRangeButton != null)
{
PreviousRangeButton.IsEnabled = ClassBreakConfigItems.SelectedIndex > 0;
}
if (NextRangeButton != null)
{
// remember .. the first item in the list is the default symbol
if (ClassBreaksRenderer != null)
{
NextRangeButton.IsEnabled = ClassBreakConfigItems.SelectedIndex < ClassBreaksRenderer.Classes.Count;
}
}
ClassBreakConfigControl classBreakConfigControl = ClassBreakConfigItems.SelectedItem as ClassBreakConfigControl;
if (classBreakConfigControl != null)
{
if (DeleteRangeButton != null)
{
DeleteRangeButton.IsEnabled = true;
}
if (classBreakConfigControl.ClassBreak == null)
{
return;
}
if (SymbolConfigControl != null && classBreakConfigControl.ClassBreak != null)
{
SymbolConfigControl.Symbol = classBreakConfigControl.ClassBreak.Symbol;
}
if (MinTextBox != null)
{
MinTextBox.IsEnabled = true;
MinTextBox.TextChanged -= MinTextBox_TextChanged;
MinTextBox.Text = classBreakConfigControl.ClassBreak.MinimumValue.ToString();
MinTextBox.TextChanged += MinTextBox_TextChanged;
}
if (MaxTextBox != null)
{
MaxTextBox.IsEnabled = true;
MaxTextBox.TextChanged -= MaxTextBox_TextChanged;
MaxTextBox.Text = classBreakConfigControl.ClassBreak.MaximumValue.ToString();
MaxTextBox.TextChanged += MaxTextBox_TextChanged;
}
}
else
{
DefaultSymbolConfigControl defaultSymbolConfigControl = ClassBreakConfigItems.SelectedItem as DefaultSymbolConfigControl;
if (defaultSymbolConfigControl != null)
{
if (SymbolConfigControl != null)
{
SymbolConfigControl.Symbol = defaultSymbolConfigControl.Symbol;
}
if (DeleteRangeButton != null)
{
DeleteRangeButton.IsEnabled = false;
}
if (MinTextBox != null)
{
MinTextBox.IsEnabled = false;
MinTextBox.TextChanged -= MinTextBox_TextChanged;
MinTextBox.Text = "";
MinTextBox.TextChanged += MinTextBox_TextChanged;
}
if (MaxTextBox != null)
{
MaxTextBox.IsEnabled = false;
MaxTextBox.TextChanged -= MaxTextBox_TextChanged;
MaxTextBox.Text = "";
MaxTextBox.TextChanged += MaxTextBox_TextChanged;
}
}
}
}
private ClassBreakConfigControl createNewClassBreakConfigControl(ClassBreakInfo classBreak)
{
ClassBreakConfigControl classBreakConfigControl = new ClassBreakConfigControl()
{
ClassBreak = classBreak,
SymbolConfigProvider = SymbolConfigProvider,
GeometryType = GeometryType,
};
classBreakConfigControl.ClassBreakModified += new EventHandler<ClassBreakModificationEventArgs>(classBreakConfigControl_ClassBreakChanged);
return classBreakConfigControl;
}
void classBreakConfigControl_ClassBreakChanged(object sender, ClassBreakModificationEventArgs e)
{
// Auto adjust adjacent class breaks
if (e.ClassBreakModificationType == ClassBreakModificationType.MinValueChanged)
{
ClassBreakConfigControl control = sender as ClassBreakConfigControl;
if (control != null)
{
int indexOfClassBreak = -1;
ClassBreakInfo classBreak = control.ClassBreak;
indexOfClassBreak = ClassBreaksRenderer.Classes.IndexOf(classBreak);
if (indexOfClassBreak > 0)
{
// Update the previous class break in the collection
if (ClassBreakConfigItems != null && ClassBreakConfigItems.Items != null)
{
int indexOfControl = ClassBreakConfigItems.Items.IndexOf(control);
if (indexOfControl > 0)// array bounds check
{
ClassBreakConfigControl prevControl = ClassBreakConfigItems.Items[indexOfControl - 1] as ClassBreakConfigControl;
if (prevControl != null)
{
ClassBreakInfo prevClassBreak = prevControl.ClassBreak;
double incr = 1.0;
double delta = 2 * incr;
double diff = prevClassBreak.MaximumValue - prevClassBreak.MinimumValue;
if (Math.Round(diff, 0) != Math.Round(diff, 4)) // dealing with precision of less than 1 integer
{
incr = 0.01;
delta = 2 * incr;
}
double newValue = classBreak.MinimumValue - incr;
if (classBreak.MinimumValue <= prevClassBreak.MinimumValue + delta)
{
// don't allow min value to drop below previous class break value
// Auto audjust the class breaks
newValue = prevClassBreak.MinimumValue + delta;
control.UpdateMinValue(newValue);
prevControl.UpdateMaxValue(newValue - incr);
}
else
{
prevControl.UpdateMaxValue(newValue);
}
}
}
}
}
}
}
else if (e.ClassBreakModificationType == ClassBreakModificationType.MaxValueChanged)
{
ClassBreakConfigControl control = sender as ClassBreakConfigControl;
if (control != null)
{
int indexOfClassBreak = -1;
ClassBreakInfo classBreak = control.ClassBreak;
indexOfClassBreak = ClassBreaksRenderer.Classes.IndexOf(classBreak);
if (indexOfClassBreak > -1 && indexOfClassBreak < ClassBreaksRenderer.Classes.Count - 1)
{
// Update following class break
if (ClassBreakConfigItems != null && ClassBreakConfigItems.Items != null)
{
int indexOfControl = ClassBreakConfigItems.Items.IndexOf(control);
if (indexOfControl > -1 && indexOfControl < ClassBreakConfigItems.Items.Count - 1)// array bounds check
{
ClassBreakConfigControl nextControl = ClassBreakConfigItems.Items[indexOfControl + 1] as ClassBreakConfigControl;
if (nextControl != null)
{
ClassBreakInfo nextClassBreak = nextControl.ClassBreak;
double incr = 1.0;
double delta = 2 * incr;
double diff = nextClassBreak.MaximumValue - nextClassBreak.MinimumValue;
if (Math.Round(diff, 0) != Math.Round(diff, 4)) // dealing with precision of less than 1 integer
{
incr = 0.01;
delta = 2 * incr;
}
double newValue = classBreak.MaximumValue + incr;
// check if the max value is greater than max of next classbreak (minus the minimum spacing)
if (classBreak.MaximumValue >= (nextClassBreak.MaximumValue - delta))
{
// don't allow max value to go above next class break value
// Auto audjust the class breaks
newValue = nextClassBreak.MaximumValue - delta;
control.UpdateMaxValue(newValue);
nextControl.UpdateMinValue(newValue + incr);
}
else
{
nextControl.UpdateMinValue(newValue);
}
}
}
}
}
}
}
SelectedClassBreakModificationEventArgs args = new SelectedClassBreakModificationEventArgs()
{
ClassBreakModificationType = e.ClassBreakModificationType,
IsSelectedItem = ClassBreakConfigItems.SelectedItem == sender,
};
OnClassBreakRendererModified(args);
}
