public bool CanEdit(IFeatureRenderer obj)
{
return (obj is IMultivariateRenderer);
}
private bool CompareRenderers(IFeatureRenderer pRend, IFeatureRenderer pCheckRend)
{
if (pRend is IClassBreaksRenderer)
{
// type
if (! (pCheckRend is IClassBreaksRenderer))
return false;
IClassBreaksRenderer pCBRend = null;
pCBRend = pRend as IClassBreaksRenderer;
IClassBreaksRenderer pCBCheckRend = null;
pCBCheckRend = pCheckRend as IClassBreaksRenderer;
// break count
if (pCBRend.BreakCount != pCBCheckRend.BreakCount)
return false;
// field
if (pCBRend.Field != pCBCheckRend.Field)
return false;
}
return true;
}
private static IRendererPropertyPage GetVectorPropertyPage(IFeatureRenderer renderer)
{
if (renderer is ClassBreaksRenderer)
{
return((IRendererPropertyPage) new GraduatedColorPropertyPage());
}
else if (renderer is SimpleRenderer)
{
return((IRendererPropertyPage) new SingleSymbolPropertyPage());
}
else if (renderer is UniqueValueRenderer)
{
return((IRendererPropertyPage) new StackedChartPropertyPage());
}
return(null);
//if (renderer is BarChartPropertyPage) return (IRendererPropertyPage)new BarChartPropertyPage();
//else if (renderer is BiUniqueValuePropertyPage) return (IRendererPropertyPage)new BiUniqueValuePropertyPage();
//else if (renderer is CadUniqueValuePropertyPage) return (IRendererPropertyPage)new CadUniqueValuePropertyPage();
//else if (renderer is CombiUniqueValuePropertyPage) return (IRendererPropertyPage)new CombiUniqueValuePropertyPage();
//else if (renderer is StackedChartPropertyPage) return (IRendererPropertyPage)new StackedChartPropertyPage();
//else if (renderer is GraduatedSymbolPropertyPage) return (IRendererPropertyPage)new GraduatedSymbolPropertyPage();
//else if (renderer is LookupSymbolPropertyPage) return (IRendererPropertyPage)new LookupSymbolPropertyPage();
//else if (renderer is MultiDotDensityPropertyPage) return (IRendererPropertyPage)new MultiDotDensityPropertyPage();
//else if (renderer is PieChartPropertyPage) return (IRendererPropertyPage)new PieChartPropertyPage();
//else if (renderer is ProportionalSymbolPropertyPage) return (IRendererPropertyPage)new ProportionalSymbolPropertyPage();
}
public static ISymbol GetSymbolFromLayer(ILayer layer)
{
if (layer == null)
{
return(null);
}
IFeatureLayer pFl = layer as IFeatureLayer;
IFeatureCursor pFc = pFl.Search(null, false);
IFeature pF = pFc.NextFeature();
if (pF == null)
{
return(null);
}
IGeoFeatureLayer pGfl = pFl as IGeoFeatureLayer;
IFeatureRenderer pFr = pGfl.Renderer;
if (pFr == null)
{
return(null);
}
ISymbol pSb = pFr.get_SymbolByFeature(pF);
return(pSb);
}
/// <summary>
/// 设置标注和矢量的绘制风格
/// </summary>
/// <param name="lyr"></param>
/// <param name="shpFname"></param>
private void TryApplyStyle(AgileMap.ILayer lyr, string shpFname)
{
string mcdfname = Path.ChangeExtension(shpFname, ".mcd");
if (!File.Exists(mcdfname))
{
return;
}
XDocument doc = XDocument.Load(mcdfname);
var result = doc.Element("Map").Element("Layers").Elements();
if (result == null)
{
return;
}
LabelDef labelDef = null;
IFeatureRenderer featureRender = null;
GetFeatureRenderFromMcd(doc, out labelDef, out featureRender);
if (labelDef != null)
{
(lyr as CodeCell.AgileMap.Core.IFeatureLayer).LabelDef = labelDef;
}
if (featureRender != null)
{
(lyr as CodeCell.AgileMap.Core.IFeatureLayer).Renderer = featureRender;
}
}
private void cboSecondaryColor_SelectedIndexChanged(object sender, System.EventArgs e)
{
m_pColorRend2 = m_pColorRendList[cboSecondaryColor.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
private void cboSize1_selectedindexchanged(object sender, System.EventArgs e)
{
m_pSizeRend = m_pSizeRendList[cboSize1.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
private void btnSymbol_Click(object sender, EventArgs e)
{
if (this.chkListRender.SelectedIndex > -1)
{
try
{
frmSymbolSelector selector = new frmSymbolSelector();
if (selector != null)
{
selector.SetStyleGallery(this.m_pSG);
selector.SetSymbol(this.btnSymbol.Style);
if (selector.ShowDialog() == DialogResult.OK)
{
this.btnSymbol.Style = selector.GetSymbol();
IFeatureRenderer renderer =
this.ilist_1[this.chkListRender.SelectedIndex] as IFeatureRenderer;
(renderer as ISimpleRenderer).Symbol = this.btnSymbol.Style as ISymbol;
}
}
}
catch
{
}
}
}
public void SetObjects(ESRI.ArcGIS.esriSystem.ISet objects)
{
// supplies the page with the object(s) to be edited including the map, feature layer,
// feature class, and renderer
// note: the feature renderer passed in as part of Objects is the one created
// in CreateCompatibleObject
object pObj = null;
if (objects.Count <= 0)
return;
objects.Reset();
pObj = objects.Next();
IMap pMap = null;
IGeoFeatureLayer pGeoLayer = null;
// in this implementation we need info from the map and the renderer
while (pObj != null)
{
if (pObj is IMap)
pMap = pObj as IMap;
if (pObj is IGeoFeatureLayer)
pGeoLayer = pObj as IGeoFeatureLayer;
if (pObj is IFeatureRenderer)
m_pRend = pObj as IFeatureRenderer;
pObj = objects.Next();
}
if ((pMap != null) & (pGeoLayer != null) & (m_pRend != null))
{
m_Page.InitControls(m_pRend as IMultivariateRenderer, pMap, pGeoLayer);
}
}
private void tvRenderer_AfterSelect(object sender, TreeViewEventArgs e)
{
if (e.Node is RendererNode)
{
btnOK.Enabled = true;
if (_selectedRenderer != ((RendererNode)e.Node).FeatureRenderer)
{
//if (_selectedRenderer != null) _selectedRenderer.Release();
_selectedRenderer = ((RendererNode)e.Node).FeatureRenderer;
}
}
else if (e.Node is LabelRendererNode)
{
btnOK.Enabled = true;
if (_selectedLabelRenderer != ((LabelRendererNode)e.Node).LabelRenderer)
{
//if (_selectedLabelRenderer != null) _selectedRenderer.Release();
_selectedLabelRenderer = ((LabelRendererNode)e.Node).LabelRenderer;
}
}
else
{
btnOK.Enabled = false;
_selectedRenderer = null;
}
}
public void AddMask(GCDCore.Project.Masks.AttributeFieldMask mask)
{
IGroupLayer pProjLyr = AddProjectGroupLayer();
IGroupLayer pGrpLayer = ArcMapUtilities.GetGroupLayer(MasksGroupLayer, pProjLyr);
short dTransparency = GCDCore.Properties.Settings.Default.TransparencyAssociatedLayers ? GCDCore.Properties.Settings.Default.AutoTransparencyValue : (short)-1;
IFeatureRenderer pRenderer = null;
string queryFilter = string.Empty;
string labelField = string.Empty;
if (mask is GCDCore.Project.Masks.RegularMask)
{
GCDCore.Project.Masks.RegularMask rMask = mask as GCDCore.Project.Masks.RegularMask;
pRenderer = VectorSymbolization.GetRegularMaskRenderer(rMask) as IFeatureRenderer;
// Create a definition query if some features are not included
if (rMask._Items.Any(x => !x.Include))
{
queryFilter = string.Format("\"{0}\" IN ('{1}')", mask._Field, string.Join("','", rMask._Items.Where(x => x.Include).Select(y => y.FieldValue)));
}
}
else if (mask is GCDCore.Project.Masks.DirectionalMask)
{
GCDCore.Project.Masks.DirectionalMask dirMask = mask as GCDCore.Project.Masks.DirectionalMask;
// Directional mask. Black outline with labels
pRenderer = VectorSymbolization.GetDirectionalMaskRenderer(dirMask) as IFeatureRenderer;
labelField = string.IsNullOrEmpty(dirMask.LabelField) ? dirMask._Field : dirMask.LabelField;
}
VectorSymbolization.AddToMapVector(mask.Vector.GISFileInfo, mask.Name, pGrpLayer, mask._Field, pRenderer, queryFilter, labelField, dTransparency);
}
private void SetFeatureSmooting(SymbolSmoothing smooting)
{
if (_map == null || _map.MapElements == null)
{
return;
}
foreach (IDatasetElement dsElement in _map.MapElements)
{
IFeatureLayer fLayer = dsElement as IFeatureLayer;
if (fLayer == null || fLayer.FeatureRenderer == null)
{
continue;
}
IFeatureRenderer fRenderer = fLayer.FeatureRenderer;
foreach (ISymbol symbol in fRenderer.Symbols)
{
if (symbol == null)
{
continue;
}
symbol.SymbolSmothingMode = smooting;
}
}
if (_app != null)
{
_app.RefreshActiveMap(DrawPhase.All);
}
}
private void RefreshFeatureRendererSymbolsGraphcisEngine()
{
if (_map == null || _map.MapElements == null)
{
return;
}
foreach (IDatasetElement dsElement in _map.MapElements)
{
IFeatureLayer fLayer = dsElement as IFeatureLayer;
if (fLayer == null || fLayer.FeatureRenderer == null)
{
continue;
}
IFeatureRenderer fRenderer = fLayer.FeatureRenderer;
foreach (ISymbol symbol in fRenderer.Symbols)
{
if (symbol is ISymbolCurrentGraphicsEngineDependent)
{
((ISymbolCurrentGraphicsEngineDependent)symbol).CurrentGraphicsEngineChanged();
}
}
}
}
/// <summary>
/// Save a feature layer of IPolygon to Ipe
/// </summary>
private static string TranIpgToIpe(IFeature pFeature, IFeatureRenderer pRenderer,
IEnvelope pFLayerEnv, CEnvelope pIpeEnv, string strBoundWidth = "normal")
{
var pFillSymbol = pRenderer.SymbolByFeature[pFeature] as IFillSymbol;
return(TranCpgToIpe(new CPolygon(0, (IPolygon4)pFeature.Shape), pFillSymbol, pFLayerEnv, pIpeEnv, strBoundWidth));
}
private void DoInit()
{
IFeatureClass fetclass = _class as IFeatureClass;
//_featureRenderer
switch (fetclass.ShapeType)
{
case enumShapeType.Point:
_featureRender = new SimpleFeatureRenderer(new SimpleMarkerSymbol());
break;
case enumShapeType.Polyline:
_featureRender = new SimpleFeatureRenderer(new SimpleLineSymbol());
break;
case enumShapeType.Polygon:
_featureRender = new SimpleFeatureRenderer(new SimpleFillSymbol());
break;
default:
throw new NotSupportedException("矢量要素层对象暂不支持\"" + fetclass.ShapeType.ToString() + "\"几何类型的数据。");
}
if ((_featureRender as BaseFeatureRenderer) != null)
{
(_featureRender as BaseFeatureRenderer)._name = _name;
}
string[] fldnames = fetclass.FieldNames;
_labelDef = new LabelDef(TryGetKeyField(fldnames, new string[] { "NAME", "名称" }), fldnames);
_rotateFieldDef = new RotateFieldDef(TryGetKeyField(fldnames, new string[] { "ANGLE", "角度" }), 0f, fldnames);
_featureRender.RotateFieldDef = _rotateFieldDef;
_isInited = true;
}
/// <summary>
/// 简单渲染方式
/// </summary>
/// <param name="pFeatureRender">渲染方式</param>
/// <param name="pFeatureLayer">渲染的目标图层</param>
public ptSimpleRendererClass(IFeatureRenderer pFeatureRender, IFeatureLayer pFeatureLayer) :
base(pFeatureRender, pFeatureLayer)
{
m_pSimpleRender = pFeatureRender as ISimpleRenderer;
m_pFeatureLayer = pFeatureLayer;
InitialSymbol();
}
public static IRgbColor GetFeatureColor(IGeoFeatureLayer igeoFeatureLayer_0, IFeature ifeature_0)
{
IRgbColor rgbColor = new RgbColor();
IFeatureRenderer renderer = igeoFeatureLayer_0.Renderer;
ISymbol symbol = renderer.get_SymbolByFeature(ifeature_0);
if (symbol is IMarkerSymbol)
{
IMarkerSymbol markerSymbol = symbol as IMarkerSymbol;
rgbColor.RGB = Convert.ToInt32(markerSymbol.Color.RGB);
}
else if (symbol is ILineSymbol)
{
ILineSymbol lineSymbol = symbol as ILineSymbol;
rgbColor.RGB = Convert.ToInt32(lineSymbol.Color.RGB);
}
else if (symbol is IFillSymbol)
{
IFillSymbol fillSymbol = symbol as IFillSymbol;
rgbColor.RGB = Convert.ToInt32(fillSymbol.Color.RGB);
}
else
{
rgbColor.RGB = System.Drawing.ColorTranslator.ToOle(System.Drawing.Color.Blue);
}
return(rgbColor);
}
public void Simplify()
{
if (_renderers == null || _renderers.Count == 0)
{
return;
}
foreach (IFeatureRenderer renderer in _renderers)
{
if (renderer is ISimplify)
{
((ISimplify)renderer).Simplify();
}
}
#region SimpleRenderer zusammenfassen
bool allSimpleRenderers = true;
foreach (IRenderer renderer in _renderers)
{
if (!(renderer is SimpleRenderer))
{
allSimpleRenderers = false;
break;
}
}
if (allSimpleRenderers)
{
IFeatureRenderer renderer = _renderers[0];
if (_renderers.Count > 1)
{
ISymbolCollection symCol = PlugInManager.Create(new Guid("062AD1EA-A93C-4c3c-8690-830E65DC6D91")) as ISymbolCollection;
foreach (IRenderer sRenderer in _renderers)
{
if (((SimpleRenderer)renderer).Symbol != null)
{
symCol.AddSymbol(((SimpleRenderer)renderer).Symbol);
}
}
((SimpleRenderer)renderer).Symbol = (ISymbol)symCol;
_renderers.Clear();
_renderers.Add(renderer);
}
}
#endregion
#region Combine Renderers
for (int i = 0; i < _renderers.Count; i++)
{
for (int j = i + 1; j < _renderers.Count; j++)
{
if (_renderers[i].Combine(_renderers[j]))
{
_renderers.RemoveAt(j);
j--;
}
}
}
#endregion
}
/// <summary>
/// 根据线要素,及图层获取符号,及线类型
/// </summary>
/// <param name="pFeature">线要素</param>
/// <param name="pLayer">图层</param>
/// <param name="linetype">线类新</param>
/// <returns>符号</returns>
public static ILineSymbol GetLineSymbol(IFeature pFeature, IFeatureLayer pLayer, out epcLineSymbol linetype)
{
IGeoFeatureLayer pGeofLayer = pLayer as IGeoFeatureLayer;
IFeatureRenderer pFRenderer = pGeofLayer.Renderer;
ISymbol pSymbol = pFRenderer.get_SymbolByFeature(pFeature);
linetype = epcLineSymbol.epcNull;
if (pSymbol is ISimpleLineSymbol)
{
linetype = epcLineSymbol.epcSimple;
}
else if (pSymbol is ICartographicLineSymbol)
{
linetype = epcLineSymbol.epcCartoGraphic;
}
else if (pSymbol is IPictureLineSymbol)
{
linetype = epcLineSymbol.epcPicture;
}
else if (pSymbol is IMultiLayerLineSymbol)
{
linetype = epcLineSymbol.epcMultiLayer;
}
if (linetype == epcLineSymbol.epcNull)
{
return(null);
}
return(pSymbol as ILineSymbol);
}
private void cboShapePattern_SelectedIndexChanged(object sender, System.EventArgs e)
{
m_pShapePatternRend = m_pShapePatternRendList[cboShapePattern.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
public void InitRendererObject(IFeatureLayer pFeatureLayer, IFeatureRenderer pRenderer, esriSymbologyStyleClass _SymbologyStyleClass)
{
List <FieldInfo> fields = ModuleCommon.GetFieldsFromLayer(pFeatureLayer, true);
m_Layer = pFeatureLayer;
InitRendererObject(fields, pRenderer, _SymbologyStyleClass);
}
public void WriteNamedLayer(string layername, IFeatureRenderer Renderer)
{
if (_closed)
{
return;
}
if (Renderer is SLDRenderer)
{
SLDRenderer sldRenderer = (SLDRenderer)Renderer;
_sw.WriteLine(sldRenderer.ToXmlString(layername));
}
else
{
_sw.WriteLine(@" <NamedLayer>
<Name>" + layername + @"</Name>
<UserStyle>
<Name>" + layername + "_style</Name>");
_sw.WriteLine(@"<FeatureTypeStyle>
<Rule>");
WriteFeatureRenderer(Renderer);
_sw.WriteLine(@"</Rule>
</FeatureTypeStyle>");
_sw.WriteLine(@"</UserStyle>
</NamedLayer>");
}
}
public object PropertyPanel(IFeatureRenderer renderer, IFeatureLayer layer)
{
_renderer = renderer as DimensionRenderer;
if (layer != null)
{
_featureClass = layer.FeatureClass;
}
InitializeComponent();
foreach (object e in Enum.GetValues(typeof(DimensionRenderer.lineCapType)))
{
cmbLineCap.Items.Add(e);
}
if (_renderer != null)
{
cmbLineCap.SelectedItem = _renderer.LineCapType;
txtFormat.Text = _renderer.LabelFormat;
}
else
{
if (cmbLineCap.Items.Count > 0)
{
cmbLineCap.SelectedIndex = 0;
}
}
return(panel1);
}
public static ISymbol GetSymbolFromLayer(ILayer layer)
{
if (layer == null)
{
return(null);
}
IFeatureLayer featureLayer = layer as IFeatureLayer;
IFeatureCursor featureCursor = featureLayer.Search(null, false);
IFeature feature = featureCursor.NextFeature();
if (feature == null)
{
return(null);
}
IGeoFeatureLayer geoFeatureLayer = featureLayer as IGeoFeatureLayer;
IFeatureRenderer featureRenderer = geoFeatureLayer.Renderer;
if (featureRenderer == null)
{
return(null);
}
ISymbol symbol = featureRenderer.get_SymbolByFeature(feature);
return(symbol);
}
public static IFeatureRenderer DoWithRenderer(IWorkspace pConfigWks, string rendererKey, string rendererSchema, IFeatureLayer featureLayer)
{
IFeatureRenderer featureRenderer = null;
try
{
string sql = "ID='" + rendererKey + "'";
object obj = GetRendererFromBlob(sql, pConfigWks);
if (featureLayer is IFDOGraphicsLayer)
{
string sAnnoRendererColor = (string)obj;
ISymbolSubstitution pSymbolSubstitution = featureLayer as ISymbolSubstitution;
pSymbolSubstitution.SubstituteType = esriSymbolSubstituteType.esriSymbolSubstituteColor;
pSymbolSubstitution.MassColor = GetRgbColorFromRgbString(sAnnoRendererColor);
}
else
{
featureRenderer = (IFeatureRenderer)obj;
}
}
catch (Exception ex)
{
}
return(featureRenderer);
}
public static ISymbol GetSymbolByLayer(ILayer layer)
{
//判断图层是否获取成功
if (layer == null)
{
return(null);
}
//利用IFeatureLayer接口访问目标图层，获取图层的第一个要素
//如果获取失败，返回空值
IFeatureLayer featurelayer = layer as IFeatureLayer;
IFeatureCursor featurecursor = featurelayer.Search(null, false);
IFeature feature = featurecursor.NextFeature();
if (feature == null)
{
return(null);
}
//通过IGeoFeatureLayer访问图层，获取图层渲染器
//如果获取失败，返回空值
IGeoFeatureLayer geofeaturelayer = featurelayer as IGeoFeatureLayer;
IFeatureRenderer featurerender = geofeaturelayer.Renderer;
if (featurerender == null)
{
return(null);
}
ISymbol symbol = featurerender.get_SymbolByFeature(feature);
/* ISimpleLineSymbol spl = (ISimpleLineSymbol)symbol;
* spl.Style = esriSimpleLineStyle.esriSLSDash;
* symbol = (ISymbol)spl;*/
return(symbol);
}
private void mnuSymbol_Click(object sender, EventArgs e)
{
ILayer pLayer = MainMap.get_Layer(0);
IGeoFeatureLayer pGeoFeatureLayer = pLayer as IGeoFeatureLayer;
IFeatureRenderer pFeatureRender = pGeoFeatureLayer.Renderer;
ISimpleRenderer pSimpleRender = pFeatureRender as ISimpleRenderer;
ILineFillSymbol pLineFillSymbol = new LineFillSymbolClass();
ILineSymbol pLineSymbol = new SimpleLineSymbolClass();
IRgbColor pRgbColor = new RgbColorClass();
pRgbColor.Red = 96;
pRgbColor.Green = 96;
pRgbColor.Blue = 196;
pLineSymbol.Color = pRgbColor as IColor;
pLineSymbol.Width = 2;
pLineFillSymbol.LineSymbol = pLineSymbol;
pLineFillSymbol.Outline = pLineSymbol;
pSimpleRender.Symbol = pLineFillSymbol as ISymbol;
MainMap.ActiveView.Refresh();
}
public RenderLayerPoint(IFeatureLayer featureLayer, MainForm frm)
{
InitializeComponent();
m_featureLayer = featureLayer;
m_fraMain = frm;
//Get properties of the current symbol
IGeoFeatureLayer geoFeatureLayer = featureLayer as IGeoFeatureLayer;
IFeatureRenderer featureRenderer = geoFeatureLayer.Renderer;
if (featureRenderer is ISimpleRenderer)
{
ISimpleRenderer simpleRenderer = geoFeatureLayer.Renderer as ISimpleRenderer;
ISimpleMarkerSymbol simpleMarkerSymbol = simpleRenderer.Symbol as ISimpleMarkerSymbol;
if (simpleMarkerSymbol != null)
{
//Get the current size of points
tbSize.Text = simpleMarkerSymbol.Size.ToString();
//Get the current color of points
IRgbColor rgbColor = new RgbColorClass();
rgbColor = simpleMarkerSymbol.Color as IRgbColor;
tbRed.Text = rgbColor.Red.ToString();
tbGreen.Text = rgbColor.Green.ToString();
tbBlue.Text = rgbColor.Blue.ToString();
//Change the value of track bar
tkbSize.Value = int.Parse(tbSize.Text);
}
}
}
private void SetRenderer(CodeCell.AgileMap.Core.IFeatureLayer fetLayer)
{
IFeatureRenderer render = fetLayer.Renderer;
SimpleFeatureRenderer sr = render as SimpleFeatureRenderer;
IFillSymbol sym = sr.Symbol as IFillSymbol;
sym.OutlineSymbol.Color = Color.Blue;
}
public void RendererIsISimpleRenderer()
{
IGeoFeatureLayer gfl = layer as IGeoFeatureLayer;
IFeatureRenderer fr = gfl.Renderer;
Type expected = typeof(IFeatureRenderer);
System.Console.WriteLine(expected.ToString() + ", " + fr.GetType().ToString());
Assert.IsInstanceOfType(expected, fr, "test ok");
}
/// <summary>
/// 获取面的符号
/// </summary>
/// <param name="pFeature">面要素</param>
/// <returns>符号</returns>
public static IFillSymbol GetFillSymbol(IFeature pFeature)
{
IFeatureLayer pfLayer = GeoDbUtils.GetFeatureLayer(pFeature);
IGeoFeatureLayer pGeofLayer = pfLayer as IGeoFeatureLayer;
IFeatureRenderer pFRenderer = pGeofLayer.Renderer;
ISymbol pSymbol = pFRenderer.get_SymbolByFeature(pFeature);
return(pSymbol as IFillSymbol);
}
public override void Compile(bool recursive = false)
{
//Debug.Assert(InputFeatureType != null);
if (_text.LabelBox != null)
{
var renderer = _text.LabelBox.Renderer as IFeatureRenderer;
if (renderer != null)
{
renderer.InputFeatureType = InputFeatureType;
if (recursive)
renderer.Compile(true);
}
}
var context = Renderer.Context;
//var colorContext = context;
//var contentAlignmentContext = context;
//_resolver = new FeatureVariableResolver(InputFeatureType);
//_resolver.BindContext(context);
//_resolver.BindContext(colorContext);
//_resolver.BindContext(contentAlignmentContext);
var oldFeatureType = Renderer.FeatureVarResolver.FeatureType;
Renderer.FeatureVarResolver.FeatureType = InputFeatureType;
try
{
_contentEvaluator = CompileExpression(context, TextStyle.ContentField, _text.Content, ref _content);
_angleEvaluator = CompileDoubleExpression(context, TextStyle.AngleField, _text.Angle, ref _angle);
_sizeEvaluator = CompileDoubleExpression(context, TextStyle.SizeField, _text.Size, ref _size);
_alignEvaluator = CompileEnumExpression(context, TextStyle.AlignmentField, _text.Alignment, ref _alignment);
_fontEvaluator = CompileExpression<string>(context, TextStyle.FontField, _text.Font);
_colorEvaluator = CompileColorExpression(context, TextStyle.ColorField, _text.Color, ref _color);
_scaleXEvaluator = CompileDoubleExpression(context, TextStyle.ScaleXField, _text.ScaleX, ref _scaleX);
_scaleYvaluator = CompileDoubleExpression(context, TextStyle.ScaleYField, _text.ScaleY, ref _scaleY);
_opacityEvaluator = CompileFloatExpression(context, TextStyle.OpacityField, _text.Opacity, ref _opacity);
_overlapableEvaluator = CompileBoolExpression(context, TextStyle.OverlapableField, _text.Overlappable, ref _overlapable);
_allowOverlapEvaluator = CompileBoolExpression(context, TextStyle.AllowOverlapField, _text.AllowOverlap, ref _allowOverlap);
}
finally
{
Renderer.FeatureVarResolver.FeatureType = oldFeatureType;
}
//_labelBoxRenderer = _text.LabelBox != null && _text.LabelBox.Renderer != null && !string.IsNullOrWhiteSpace(_text.Content)
// ? _text.LabelBox.Renderer as IFeatureRenderer
// : null;
_labelBoxRenderer = _text.LabelBox != null ? new ContainerNodeRenderer(Renderer, _text.LabelBox, this) : null;
_compiled = true;
}
private bool CompareRenderers(IFeatureRenderer pRend, IFeatureRenderer pCheckRend)
{
if (pRend is IClassBreaksRenderer)
{
// type
if (! (pCheckRend is IClassBreaksRenderer))
return false;
IClassBreaksRenderer pCBRend = null;
pCBRend = pRend as IClassBreaksRenderer;
IClassBreaksRenderer pCBCheckRend = null;
pCBCheckRend = pCheckRend as IClassBreaksRenderer;
// break count
if (pCBRend.BreakCount != pCBCheckRend.BreakCount)
return false;
// field
if (pCBRend.Field != pCBCheckRend.Field)
return false;
}
return true;
}
//public bool DisplayPrimaryFlowDirections(ref Dictionary<string, SectionObject> sectionElements, ref Dictionary<string, NodeObject> nElements)
public bool DisplayPrimaryFlowDirections()
{
bool isSuccess = true;
IGeoFeatureLayer geoFeatLayer = null;
try
{
if (this._primaryLyr != null && this._primaryLyr is IGeoFeatureLayer)
{
geoFeatLayer = this._primaryLyr as IGeoFeatureLayer;
if (geoFeatLayer != null)
{
IFeatureRenderer featRenderer = geoFeatLayer.Renderer;
IObjectCopy objCopy = new ObjectCopyClass();
//this._oldfeatRenderer = objCopy.Copy(featRenderer) as IFeatureRenderer;
this._oldPrimaryRenderer = geoFeatLayer.Renderer;
//if (priFlowDirs != null)
// {
FlowDirection flowDirection = new FlowDirection();
flowDirection.FeatureRenderer = this._oldPrimaryRenderer;
flowDirection.FeatureSelection = this._primaryLyr as IFeatureSelection;
//Commented it because I am doing it inside Renderer class
// flowDirection.SelectedOIDs = this.SelectedOIDs(flowDirection.FeatureSelection);
// flowDirection.SectionElements = sectionElements;
//flowDirection.NodeElements = nElements;
//flowDirection.PrimaryFlowDirections = priFlowDirs;
geoFeatLayer.Renderer = flowDirection;
this._activeView.ContentsChanged();
this._activeView.Refresh();
isSuccess = true;
// }
}
}
else
isSuccess = false;
}
catch (Exception ex)
{
if (this._oldPrimaryRenderer != null && geoFeatLayer != null)
{
geoFeatLayer.Renderer = this._oldPrimaryRenderer;
this._activeView.ContentsChanged();
this._activeView.Refresh();
}
isSuccess = false;
}
finally
{
//if (utilityNetwork != null) System.Runtime.InteropServices.Marshal.ReleaseComObject(utilityNetwork);
}
return isSuccess;
}
private bool RendererIsValidForType(IFeatureRenderer pFeatRend, eRendererType eMultiRendType)
{
// indicates whether or not pFeatRend is valid for the eMultiRendType for the current layer
// e.g. if pFeatRend is an IProportionalSymbolRenderer, then it's valid for eMultiRendType = eSize
ILegendInfo pLegendInfo = null;
if (eMultiRendType == eRendererType.eShapePattern)
return pFeatRend is IUniqueValueRenderer;
else if (eMultiRendType == eRendererType.eColor)
{
pLegendInfo = pFeatRend as ILegendInfo;
return (pFeatRend is IUniqueValueRenderer) | (pFeatRend is IClassBreaksRenderer & ! pLegendInfo.SymbolsAreGraduated);
}
else // size
{
pLegendInfo = pFeatRend as ILegendInfo;
return (pFeatRend is IClassBreaksRenderer & pLegendInfo.SymbolsAreGraduated) | (pFeatRend is IProportionalSymbolRenderer);
}
}
public void InitControls(IMultivariateRenderer pMultiRend, IMap pMap, IGeoFeatureLayer pGeoLayer)
{
// copy properties from the renderer and map to the form
m_eColorCombinationMethod = pMultiRend.ColorCombinationMethod;
m_pShapePatternRend = pMultiRend.ShapePatternRend;
m_pColorRend1 = pMultiRend.ColorRend1;
m_pColorRend2 = pMultiRend.ColorRend2;
m_pSizeRend = pMultiRend.SizeRend;
if (m_pShapePatternRend != null)
{
chkShapePattern.CheckState = System.Windows.Forms.CheckState.Checked;
cboShapePattern.Enabled = true;
}
if (m_eColorCombinationMethod == EColorCombinationType.enuComponents)
{
radComponents.Checked = true;
radCombination.Checked = false;
UpdateColorComb();
}
else
{
//disabled
//radComponents.Checked = false;
//radCombination.Checked = true;
radComponents.Checked = true;
radCombination.Checked = false;
UpdateColorComb();
}
if (m_pColorRend1 != null)
{
chkColor.CheckState = System.Windows.Forms.CheckState.Checked;
radComponents.Enabled = true;
//disabled
//radCombination.Enabled = true;
radCombination.Enabled = false;
}
if (m_pSizeRend != null)
{
chkSize.CheckState = System.Windows.Forms.CheckState.Checked;
cboSize1.Enabled = true;
}
IRotationRenderer pRotRend = null;
pRotRend = pMultiRend as IRotationRenderer;
if (pRotRend.RotationField != "")
{
chkRotation.CheckState = System.Windows.Forms.CheckState.Checked;
butRotation.Enabled = true;
}
//ITransparencyRenderer pTransRend = null;
//pTransRend = pMultiRend as ITransparencyRenderer;
//if (pTransRend.TransparencyField != "")
//{
// chkTransparency.CheckState = System.Windows.Forms.CheckState.Checked;
// butTransparency.Enabled = true;
//}
m_pMap = pMap;
m_pCurrentLayer = pGeoLayer;
m_pRend = pMultiRend as IFeatureRenderer; // we need this object to support the root transparency dialogs
m_PageIsDirty = false;
}
private void cboSecondaryColor_SelectedIndexChanged(object sender, System.EventArgs e)
{
m_pColorRend2 = m_pColorRendList[cboSecondaryColor.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
public void Load(IVariantStream Stream)
{
//load the persisted parameters of the renderer
m_eColorCombinationMethod = (EColorCombinationType)Stream.Read();
m_pShapePatternRend = Stream.Read() as IFeatureRenderer;
m_pColorRend1 = Stream.Read() as IFeatureRenderer;
m_pColorRend2 = Stream.Read() as IFeatureRenderer;
m_pSizeRend = Stream.Read() as IFeatureRenderer;
//m_pLegendGroups = = Stream.Read
m_sRotationField = (string)Stream.Read();
m_eRotationType = (esriSymbolRotationType)Stream.Read();
m_sTransparencyField = (String)Stream.Read();
m_pMainRend = Stream.Read() as IFeatureRenderer;
//CreateLegend() ' not needed now
}
private void cboShapePattern_SelectedIndexChanged(object sender, System.EventArgs e)
{
m_pShapePatternRend = m_pShapePatternRendList[cboShapePattern.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
private void cboSize1_selectedindexchanged(object sender, System.EventArgs e)
{
m_pSizeRend = m_pSizeRendList[cboSize1.SelectedIndex];
if (m_pSite != null)
m_pSite.PageChanged();
m_PageIsDirty = true;
}
