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); }