///// <summary>
///// Initializes a new, empty features layer
///// which handles <see cref="FeatureDataTable.SelectRequested"/>
///// events from <see cref="Features"/>.
///// </summary>
//protected FeatureLayer(IFeatureProvider dataSource)
// : this(String.Empty, dataSource) { }
///// <summary>
///// Initializes a new features layer with the given name and datasource
///// and which handles <see cref="FeatureDataTable.SelectRequested"/>
///// events from <see cref="Features"/>.
///// </summary>
///// <param name="layername">Name of the layer.</param>
///// <param name="dataSource">Data source.</param>
//protected FeatureLayer(String layername, IFeatureProvider dataSource)
// : this(layername, new FeatureStyle(), dataSource) { }
/// <summary>
/// Initializes a new features layer with the given name, style and datasource
/// and which handles <see cref="FeatureDataTable.SelectRequested"/>
/// events from <see cref="Features"/>.
/// </summary>
/// <param name="layername">Name of the layer.</param>
/// <param name="style">Style to apply to the layer.</param>
/// <param name="dataSource">Data source.</param>
protected FeatureLayer(String layername,
FeatureStyle style,
IFeatureProvider dataSource)
: base(layername, style, dataSource)
{
//ShouldHandleFeaturesNotFoundEvent = handleFeatureDataRequest;
// We need to get the schema of the feature table.
DataSource.Open();
_features = DataSource.CreateNewTable()
?? new FeatureDataTable(dataSource.GeometryFactory);
GeometryFactory = dataSource.GeometryFactory;
DataSource.Close();
// We generally want spatial indexing on the feature table...
_features.IsSpatiallyIndexed = true;
// handle the request on the feature data table for features
_features.SelectRequested += handleFeaturesSelectRequested;
// setup selected and highlighted views
_selectedFeatures = new FeatureDataView(_features,
(FeatureQueryExpression)null,
"",
DataViewRowState.CurrentRows);
_selectedFeatures.IsViewDefinitionExclusive = true;
_highlightedFeatures = new FeatureDataView(_features,
(FeatureQueryExpression)null,
"",
DataViewRowState.CurrentRows);
_highlightedFeatures.IsViewDefinitionExclusive = true;
}
private void SetItemInternal(object item, double previewScale, int themeCategory)
{
m_prt = item as IPointRule;
m_lrt = item as ILineRule;
m_art = item as IAreaRule;
m_comp = item as ICompositeRule;
try
{
m_isUpdating = true;
if (m_prt != null)
{
RuleCondition.Text = m_prt.Filter;
LegendLabel.Text = m_prt.LegendLabel;
Image w2d = null;
if (m_prt.PointSymbolization2D != null)
{
//Determine if this is a w2d symbol style
if (m_prt.PointSymbolization2D.Symbol.Type == PointSymbolType.W2D)
{
var sym = (IW2DSymbol)m_prt.PointSymbolization2D.Symbol;
w2d = SymbolPicker.GetSymbol(_conn, sym.W2DSymbol.ResourceId, sym.W2DSymbol.LibraryItemName);
}
}
FeatureStyle.SetItem(m_prt, m_prt.PointSymbolization2D, w2d, previewScale, themeCategory);
LabelStyle.SetItem(m_prt, m_prt.Label, previewScale, themeCategory);
LabelStyle.Visible = true;
}
else if (m_lrt != null)
{
RuleCondition.Text = m_lrt.Filter;
LegendLabel.Text = m_lrt.LegendLabel;
FeatureStyle.SetItem(m_lrt, m_lrt.Strokes, previewScale, themeCategory);
LabelStyle.SetItem(m_lrt, m_lrt.Label, previewScale, themeCategory);
LabelStyle.Visible = true;
}
else if (m_art != null)
{
RuleCondition.Text = m_art.Filter;
LegendLabel.Text = m_art.LegendLabel;
FeatureStyle.SetItem(m_art, m_art.AreaSymbolization2D, previewScale, themeCategory);
LabelStyle.SetItem(m_art, m_art.Label, previewScale, themeCategory);
LabelStyle.Visible = true;
}
else if (m_comp != null)
{
RuleCondition.Text = m_comp.Filter;
LegendLabel.Text = m_comp.LegendLabel;
FeatureStyle.SetItem(m_comp, m_comp.CompositeSymbolization, previewScale, themeCategory);
LabelStyle.Visible = false;
}
}
finally
{
m_isUpdating = false;
}
}
void layer_BeforePointRender(object sender, FeatureRenderEventArgs e)
{
if (_useExtesion)
{
FeatureStyle fs = GetStyle(e.Feature);
e.Feature.PointStyle = fs.PointStyle;
e.Feature.TitleStyle = fs.TitleStyle;
}
}
public StyleEditor(FeatureStyle style)
: base()
{
this.filterStyleEditors = new List <FilterStyleEditor>();
this.style = style;
foreach (var filterStyle in style.FilterStyles)
{
filterStyleEditors.Add(new FilterStyleEditor(filterStyle));
}
}
void OnEnable()
{
featureStyle = (FeatureStyle)target;
styleEditor = featureStyle.Editor as StyleEditor;
if (styleEditor == null)
{
styleEditor = new StyleEditor(featureStyle);
featureStyle.Editor = styleEditor;
}
}
private void processRules(XmlNode rules)
{
foreach (XmlNode node in rules.ChildNodes)
{
if (node.Name == "rule")
{
string value = node.Attributes["value"].Value;
FeatureStyle fs = new FeatureStyle();
processPointStyle(node, fs.PointStyle);
processPolygonStyle(node, fs.PolygonStyle);
processPolylineStyle(node, fs.PolylineStyle);
processTitleStyle(node, fs.TitleStyle);
_rules.Add(value, fs);
}
}
}
protected override void NotifyLayersChanged(ListChangedType listChangedType, int oldIndex, int newIndex, PropertyDescriptor propertyDescriptor)
{
switch (listChangedType)
{
case ListChangedType.ItemChanged:
if (propertyDescriptor.Name == Layer.EnabledProperty.Name)
{
ILayer layer = Map.Layers[newIndex];
IEnumerable <ILayer> layers = layer as IEnumerable <ILayer>;
if (layers != null)
{
foreach (ILayer child in layers)
{
if (child.Enabled)
{
View.EnableLayer(child.LayerName);
}
else
{
View.DisableLayer(child.LayerName);
}
}
}
else if (layer.Enabled)
{
View.EnableLayer(layer.LayerName);
}
else
{
View.DisableLayer(layer.LayerName);
}
}
else if (propertyDescriptor.Name == LayerGroup.ShowChildrenProperty.Name)
{
ILayer layer = Map.Layers[newIndex];
if ((Boolean)layer.GetPropertyValue(LayerGroup.ShowChildrenProperty))
{
View.EnableChildLayers(layer.LayerName);
}
else
{
View.DisableChildLayers(layer.LayerName);
}
}
else if (propertyDescriptor.Name == FeatureLayer.AreFeaturesSelectableProperty.Name)
{
ILayer layer = Map.Layers[newIndex];
FeatureStyle style = layer.Style as FeatureStyle;
if (style != null && style.AreFeaturesSelectable)
{
View.SetFeaturesSelectable(layer.LayerName, true);
}
else
{
View.SetFeaturesSelectable(layer.LayerName, false);
}
}
break;
// The following are taken care of by data binding:
//case ListChangedType.ItemMoved:
//case ListChangedType.ItemAdded:
//case ListChangedType.ItemDeleted:
default:
break;
}
base.NotifyLayersChanged(listChangedType, oldIndex, newIndex, propertyDescriptor);
}
internal void SetThemeOffset(int offset)
{
FeatureStyle.SetThemeOffset(offset);
}
private void processRules(XmlNode rules)
{
foreach (XmlNode node in rules.ChildNodes)
{
if (node.Name=="rule")
{
string value = node.Attributes["value"].Value;
FeatureStyle fs = new FeatureStyle();
processPointStyle(node,fs.PointStyle);
processPolygonStyle(node, fs.PolygonStyle);
processPolylineStyle(node,fs.PolylineStyle);
processTitleStyle(node, fs.TitleStyle);
_rules.Add(value,fs);
}
}
}
protected override void RenderFeatureLayer(IFeatureLayer layer, RenderPhase phase)
{
IFeatureRenderer renderer = GetRenderer <IFeatureRenderer>(layer);
renderer.RenderTransform = ToViewTransform;
Debug.Assert(renderer != null);
Debug.Assert(layer.Style is FeatureStyle);
FeatureStyle layerStyle = layer.Style as FeatureStyle;
switch (phase)
{
case RenderPhase.Normal:
IEnumerable <FeatureDataRow> features
=
EnumerateWhileMonitoringClientConnection(layer.Features.Select(ViewEnvelopeInternal.ToGeometry()));
foreach (FeatureDataRow feature in features)
{
FeatureStyle style = getStyleForFeature(layer, feature, layerStyle);
IEnumerable renderedFeature = renderer.RenderFeature(feature,
style,
RenderState.Normal,
layer);
View.ShowRenderedObjects(renderedFeature);
}
break;
case RenderPhase.Selected:
IEnumerable <FeatureDataRow> selectedRows =
EnumerateWhileMonitoringClientConnection(layer.SelectedFeatures);
foreach (FeatureDataRow selectedFeature in selectedRows)
{
FeatureStyle style = getStyleForFeature(layer, selectedFeature, layerStyle);
IEnumerable renderedFeature = renderer.RenderFeature(selectedFeature,
style,
RenderState.Selected,
layer);
View.ShowRenderedObjects(renderedFeature);
}
break;
case RenderPhase.Highlighted:
IEnumerable <FeatureDataRow> highlightedRows =
EnumerateWhileMonitoringClientConnection(layer.HighlightedFeatures);
foreach (FeatureDataRow highlightedFeature in highlightedRows)
{
FeatureStyle style = getStyleForFeature(layer, highlightedFeature, layerStyle);
IEnumerable renderedFeature = renderer.RenderFeature(highlightedFeature,
style,
RenderState.Highlighted,
layer);
View.ShowRenderedObjects(renderedFeature);
}
break;
default:
break;
}
renderer.CleanUp();
}
