internal NameValueCollection GetPropertyMappings(MgLayerBase layer)
{
MgResourceIdentifier resId = layer.GetLayerDefinition();
string resIdStr = resId.ToString();
if (_propertyMappings.ContainsKey(resIdStr))
{
return(_propertyMappings[resIdStr]);
}
MgByteReader content = _resSvc.GetResourceContent(resId);
XmlDocument doc = new XmlDocument();
string xml = content.ToString();
doc.LoadXml(xml);
XmlNodeList propMaps = doc.GetElementsByTagName("PropertyMapping"); //NOXLATE
if (propMaps.Count > 0)
{
NameValueCollection propertyMappings = new NameValueCollection();
foreach (XmlNode pm in propMaps)
{
propertyMappings[pm["Name"].InnerText] = pm["Value"].InnerText; //NOXLATE
}
_propertyMappings[resIdStr] = propertyMappings;
}
else
{
//NULL is a legit dictionary value
_propertyMappings[resIdStr] = null;
}
return(_propertyMappings[resIdStr]);
}
private void button1_Click(object sender, EventArgs e)
{
try
{
var fact = new MgdServiceFactory();
MgResourceService resSvc = (MgResourceService)fact.CreateService(MgServiceType.ResourceService);
MgResourceIdentifier resId = new MgResourceIdentifier(textBox1.Text);
MgByteReader reader = resSvc.GetResourceContent(resId);
new XmlResponseDialog(reader).ShowDialog();
}
catch (MgException ex)
{
MessageBox.Show(ex.ToString(), "Error from MapGuide");
}
}
private string[] GetScaleRanges(MgLayerBase layer)
{
if (_resSvc == null)
{
var provider = _viewer.GetProvider();
_resSvc = (MgResourceService)provider.CreateService(MgServiceType.ResourceService);
}
MgResourceIdentifier layerDefResId = layer.GetLayerDefinition();
MgByteReader byteReader = _resSvc.GetResourceContent(layerDefResId);
XmlDocument doc = new XmlDocument();
doc.LoadXml(byteReader.ToString());
XmlNodeList nodeList = doc.GetElementsByTagName("VectorScaleRange"); //NOXLATE
var scaleRanges = new List <string>();
foreach (XmlElement node in nodeList)
{
String range = null;
XmlNodeList minNodeList = node.GetElementsByTagName("MinScale"); //NOXLATE
if (minNodeList.Count > 0)
{
range = minNodeList.Item(0).FirstChild.Value;
}
else
{
range = "0"; //NOXLATE
}
XmlNodeList maxNodeList = node.GetElementsByTagName("MaxScale"); //NOXLATE
if (maxNodeList.Count > 0)
{
range = range + " - " + maxNodeList.Item(0).FirstChild.Value; //NOXLATE
}
else
{
range = range + " - " + Strings.Infinity; //NOXLATE
}
scaleRanges.Add(range);
}
return(scaleRanges.ToArray());
}
public static bool DataSourceExists(MgResourceService resourceSrvc, MgResourceIdentifier dataSourceId)
{
try
{
string MGServerVersion = ConfigurationManager.AppSettings["MGServerVersion"];
if (MGServerVersion == "2009")
{
MgByteReader cnt = resourceSrvc.GetResourceContent(dataSourceId);
cnt = null;
return true;
}
return resourceSrvc.ResourceExists(dataSourceId);
}
catch (MgResourceNotFoundException)
{
return false;
}
}
public RedlineStyle GetLayerStyle(RedlineLayer layer)
{
var style = RedlineStyle.CreateDefault();
var ldfId = new MgResourceIdentifier(layer.LayerDefinition);
var br = _resSvc.GetResourceContent(ldfId);
var doc = new XmlDocument();
doc.LoadXml(br.ToString());
if (layer.StyleType == RedlineStylizationType.Basic)
{
var vsr = doc.GetElementsByTagName("VectorScaleRange")[0];
var pts = vsr["PointTypeStyle"];
var ats = vsr["AreaTypeStyle"];
var lts = vsr["LineTypeStyle"];
if (pts != null)
{
var label = (XmlElement)pts.GetElementsByTagName("Label")[0];
var psym = pts.GetElementsByTagName("PointSymbolization2D");
if (psym.Count > 0)
{
var mark = psym[0]["Mark"];
style.MarkerSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(mark, "Unit"));
style.MarkerSize = Convert.ToDouble(GetNodeValue(mark, "SizeX"));
style.MarkerType = ParseEnumValue <MarkerType>(GetNodeValue(mark, "Shape"));
style.MarkerColor = Util.FromHtmlColor(GetNodeValue(mark, "ForegroundColor"), false);
}
style.LabelSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(label, "Unit"));
style.LabelFontSize = Convert.ToDouble(GetNodeValue(label, "SizeX"));
style.LabelForeColor = Util.FromHtmlColor(GetNodeValue(label, "ForegroundColor"), false);
style.LabelBackColor = Util.FromHtmlColor(GetNodeValue(label, "BackgroundColor"), false);
style.LabelBackStyle = ParseEnumValue <LabelStyle>(GetNodeValue(label, "BackgroundStyle"));
style.LabelBold = Convert.ToBoolean(GetNodeValue(label, "Bold"));
style.LabelItalic = Convert.ToBoolean(GetNodeValue(label, "Italic"));
style.LabelUnderline = Convert.ToBoolean(GetNodeValue(label, "Underlined"));
}
if (lts != null)
{
var label = (XmlElement)lts.GetElementsByTagName("Label")[0];
style.LabelSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(label, "Unit"));
style.LabelFontSize = Convert.ToDouble(GetNodeValue(label, "SizeX"));
style.LabelForeColor = Util.FromHtmlColor(GetNodeValue(label, "ForegroundColor"), false);
style.LabelBackColor = Util.FromHtmlColor(GetNodeValue(label, "BackgroundColor"), false);
style.LabelBackStyle = ParseEnumValue <LabelStyle>(GetNodeValue(label, "BackgroundStyle"));
if (pts == null)
{
style.LabelBold = Convert.ToBoolean(GetNodeValue(label, "Bold"));
style.LabelItalic = Convert.ToBoolean(GetNodeValue(label, "Italic"));
style.LabelUnderline = Convert.ToBoolean(GetNodeValue(label, "Underlined"));
}
var lsym = lts.GetElementsByTagName("LineSymbolization2D");
if (lsym.Count > 0)
{
var line = (XmlElement)lsym[0];
style.LinePattern = ParseEnumValue <LinePattern>(GetNodeValue(line, "LineStyle"));
style.LineThickness = Convert.ToDouble(GetNodeValue(line, "Thickness"));
style.LineColor = Util.FromHtmlColor(GetNodeValue(line, "Color"), false);
style.LineSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(line, "Unit"));
}
}
if (ats != null)
{
var label = (XmlElement)ats.GetElementsByTagName("Label")[0];
style.LabelSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(label, "Unit"));
style.LabelFontSize = Convert.ToDouble(GetNodeValue(label, "SizeX"));
style.LabelForeColor = Util.FromHtmlColor(GetNodeValue(label, "ForegroundColor"), false);
style.LabelBackColor = Util.FromHtmlColor(GetNodeValue(label, "BackgroundColor"), false);
style.LabelBackStyle = ParseEnumValue <LabelStyle>(GetNodeValue(label, "BackgroundStyle"));
if (pts == null && lts == null)
{
style.LabelBold = Convert.ToBoolean(GetNodeValue(label, "Bold"));
style.LabelItalic = Convert.ToBoolean(GetNodeValue(label, "Italic"));
style.LabelUnderline = Convert.ToBoolean(GetNodeValue(label, "Underlined"));
}
var asym = ats.GetElementsByTagName("AreaSymbolization2D");
if (asym.Count > 0)
{
var fill = asym[0]["Fill"];
var stroke = asym[0]["Stroke"];
style.FillPattern = ParseEnumValue <FillPattern>(GetNodeValue(fill, "FillPattern"));
style.FillForeColor = Util.FromHtmlColor(GetNodeValue(fill, "ForegroundColor"), false);
style.FillBackColor = Util.FromHtmlColor(GetNodeValue(fill, "BackgroundColor"), false);
style.BorderPattern = ParseEnumValue <LinePattern>(GetNodeValue(stroke, "LineStyle"));
style.BorderThickness = Convert.ToDouble(GetNodeValue(stroke, "Thickness"));
style.BorderColor = Util.FromHtmlColor(GetNodeValue(stroke, "Color"));
style.BorderSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(stroke, "Unit"));
}
}
}
else
{
var extData = doc.GetElementsByTagName("ExtendedData1");
if (extData.Count == 1)
{
var ext = (XmlElement)extData[0];
style.MarkerColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_MARKER_COLOR"));
style.MarkerType = ParseEnumValue <MarkerType>(GetNodeValue(ext, "MG_MARKER_TYPE"));
style.MarkerSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(ext, "MG_MARKER_UNITS"));
style.MarkerSize = Convert.ToDouble(GetNodeValue(ext, "MG_MARKER_SIZE"));
style.LineColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_LINE_COLOR"));
style.LinePattern = ParseEnumValue <LinePattern>(GetNodeValue(ext, "MG_LINE_PATTERN"));
style.LineSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(ext, "MG_LINE_UNITS"));
style.LineThickness = Convert.ToDouble(GetNodeValue(ext, "MG_LINE_THICKNESS"));
style.FillPattern = ParseEnumValue <FillPattern>(GetNodeValue(ext, "MG_FILL_PATTERN"));
style.FillTransparency = 100 - ((Convert.ToInt32(GetNodeValue(ext, "MG_FILL_FORE_TRANSPARENCY"), 16) / 255.0) * 100.0);
style.FillForeColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_FILL_FORE_COLOR"));
style.FillBackColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_FILL_BACK_COLOR"));
style.FillBackTransparency = (GetNodeValue(ext, "MG_FILL_BACK_TRANSPARENCY") == "FF");
style.BorderPattern = ParseEnumValue <LinePattern>(GetNodeValue(ext, "MG_BORDER_PATTERN"));
style.BorderSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(ext, "MG_BORDER_UNITS"));
style.BorderColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_BORDER_COLOR"));
style.BorderThickness = Convert.ToDouble(GetNodeValue(ext, "MG_BORDER_THICKNESS"));
style.LabelSizeUnits = ParseEnumValue <SizeUnit>(GetNodeValue(ext, "MG_LABEL_FONT_UNITS"));
style.LabelFontSize = Convert.ToDouble(GetNodeValue(ext, "MG_LABEL_FONT_SIZE"));
style.LabelBold = Convert.ToBoolean(GetNodeValue(ext, "MG_BOLD"));
style.LabelItalic = Convert.ToBoolean(GetNodeValue(ext, "MG_ITALIC"));
style.LabelUnderline = Convert.ToBoolean(GetNodeValue(ext, "MG_UNDERLINE"));
style.LabelForeColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_LABEL_FORECOLOR"));
style.LabelBackColor = Util.FromHtmlColor(GetNodeValue(ext, "MG_LABEL_BACKCOLOR"));
style.LabelBackStyle = ParseEnumValue <LabelStyle>(GetNodeValue(ext, "MG_LABEL_STYLE"));
}
}
return(style);
}
//----------------------------------------------------------------------------------------
// �� �ܣ� �ж���Դ�Ƿ����
//
// �� �ߣ�
//
//
// �� �ڣ�2007.05.#
//
//-----------------------------------------------------------------------------------------
public bool IsDataSourceExists(MgResourceService resourceService, MgResourceIdentifier dataSourceId)
{
try
{
MgByteReader cnt = resourceService.GetResourceContent(dataSourceId);
return true;
}
catch (MgResourceNotFoundException)
{
return false;
}
}
private string ApplyTheme(ThemeParams themeParams)
{
var provider = _viewer.GetProvider();
var map = _viewer.GetMap();
var layers = map.GetLayers();
MgResourceService resourceService = (MgResourceService)provider.CreateService(MgServiceType.ResourceService);
MgFeatureService featureService = (MgFeatureService)provider.CreateService(MgServiceType.FeatureService);
MgResourceIdentifier resId = new MgResourceIdentifier(themeParams.layer.GetFeatureSourceId());
MgResourceIdentifier layerDefResId = themeParams.layer.GetLayerDefinition();
MgByteReader byteReader = resourceService.GetResourceContent(layerDefResId);
// Load the Layer Definition and Navigate to the specified <VectorScaleRange>
XmlDocument doc = new XmlDocument();
String xmlLayerDef = byteReader.ToString();
doc.LoadXml(xmlLayerDef);
XmlNodeList nodeList = doc.GetElementsByTagName("VectorScaleRange"); //NOXLATE
XmlElement vectorScaleRangecElement = (XmlElement)nodeList.Item(themeParams.scaleRangeIndex);
XmlElement areaTypeStyle = (XmlElement)vectorScaleRangecElement.GetElementsByTagName("AreaTypeStyle").Item(0); //NOXLATE
// Remove any existing <AreaRule> elements.
XmlNodeList areaRuleList = areaTypeStyle.GetElementsByTagName("AreaRule"); //NOXLATE
int count = areaRuleList.Count;
for (int i = 0; i < count; i++)
{
//The areaRuleList shrinks as we remove items, so always
//remove the first item (don't use the index i)
areaTypeStyle.RemoveChild(areaRuleList.Item(0));
}
// Now create the new <AreaRule> elements.
String areaRuleTemplate = Properties.Resources.AreaRuleTemplate;
MgFeatureAggregateOptions aggregateOptions = new MgFeatureAggregateOptions();
String value = null;
String filterText = null;
String areaRuleXML = null;
XmlDocument areaDoc = null;
XmlNode areaNode = null;
double portion = 0.0;
double increment = (themeParams.numRules > 1) ? 1.0 / (themeParams.numRules - 1) : 1.0;
if (THEME_INDIVIDUAL == themeParams.distro)
{
aggregateOptions.AddComputedProperty("THEME_VALUE", "UNIQUE(\"" + themeParams.property.Name + "\")"); //NOXLATE
MgDataReader dataReader = featureService.SelectAggregate(resId, themeParams.layer.GetFeatureClassName(), aggregateOptions);
while (dataReader.ReadNext())
{
value = Util.GetFeaturePropertyValue(dataReader, "THEME_VALUE"); //NOXLATE
filterText = """ + themeParams.property.Name + "" = "; //NOXLATE
if (themeParams.property.DataType == MgPropertyType.String)
{
filterText = filterText + "'" + value + "'"; //NOXLATE
}
else
{
filterText = filterText + value;
}
areaRuleXML = String.Format(areaRuleTemplate,
themeParams.property.Name + ":" + value, //NOXLATE
filterText,
Util.InterpolateColor(portion, themeParams.fillFrom, themeParams.fillTo, themeParams.fillTrans),
Util.InterpolateColor(portion, themeParams.borderFrom, themeParams.borderTo, 0));
areaDoc = new XmlDocument();
areaDoc.LoadXml(areaRuleXML);
areaNode = doc.ImportNode(areaDoc.DocumentElement, true);
areaTypeStyle.AppendChild(areaNode);
portion = portion + increment;
}
dataReader.Close();
}
else
{
var values = new List <string>();
var expr = themeParams.distro + "(\"" + themeParams.property.Name + "\"," + themeParams.numRules + "," + themeParams.minValue + "," + themeParams.maxValue + ")"; //NOXLATE
aggregateOptions.AddComputedProperty("THEME_VALUE", expr); //NOXLATE
MgDataReader dataReader = featureService.SelectAggregate(resId, themeParams.layer.GetFeatureClassName(), aggregateOptions);
while (dataReader.ReadNext())
{
value = Util.GetFeaturePropertyValue(dataReader, "THEME_VALUE"); //NOXLATE
values.Add(value);
}
dataReader.Close();
for (int i = 0; i < values.Count - 1; i++)
{
filterText = """ + themeParams.property.Name + "" >= " + values[i] + " AND "" + themeParams.property.Name; //NOXLATE
if (i == values.Count - 1)
{
filterText = filterText + "" <= " + values[i + 1]; //NOXLATE
}
else
{
filterText = filterText + "" < " + values[i + 1]; //NOXLATE
}
areaRuleXML = String.Format(areaRuleTemplate,
themeParams.property.Name + ":" + values[i] + " - " + values[i + 1], //NOXLATE
filterText,
Util.InterpolateColor(portion, themeParams.fillFrom, themeParams.fillTo, themeParams.fillTrans),
Util.InterpolateColor(portion, themeParams.borderFrom, themeParams.borderTo, 0));
areaDoc = new XmlDocument();
areaDoc.LoadXml(areaRuleXML);
areaNode = doc.ImportNode(areaDoc.DocumentElement, true);
areaTypeStyle.AppendChild(areaNode);
portion = portion + increment;
}
}
// Now save our new layer definition to the session and add it to the map.
String xmlString = doc.DocumentElement.OuterXml;
String uniqueName = Util.MakeUniqueLayerName(map, themeParams.layer.Name, themeParams.themeName);
String legendLabel = themeParams.layer.GetLegendLabel();
if (!string.IsNullOrEmpty(themeParams.themeName))
{
legendLabel = legendLabel + " (" + themeParams.themeName + ")"; //NOXLATE
}
MgResourceIdentifier layerResId = new MgResourceIdentifier("Session:" + _sessionId + "//" + uniqueName + ".LayerDefinition"); //NOXLATE
resourceService.SetResource(layerResId, new MgByteReader(xmlString, "text/xml"), null); //NOXLATE
var newLayer = provider.CreateLayer(layerResId);
newLayer.SetName(uniqueName);
newLayer.SetLegendLabel(legendLabel);
newLayer.SetDisplayInLegend(themeParams.layer.GetDisplayInLegend());
newLayer.SetVisible(true);
newLayer.SetSelectable(themeParams.layer.GetSelectable());
//HACK: This has to be true otherwise owner-drawn nodes will not display its children (the theme rules)
provider.SetLayerExpandInLegend(newLayer, true);
layers.Insert(layers.IndexOf(themeParams.layer), newLayer);
//map.Save(resourceService);
return(uniqueName);
}
LayerLegendInfo GetLayerContent(MgResourceService resourceService, MgLayer layer, double scale)
{
bool insertInToList = false;
string[] styleTypes = new[] { "PointTypeStyle", "LineTypeStyle", "AreaTypeStyle", "CompositeTypeStyle" };
string[] ruleNames = new[] { "PointRule", "LineRule", "AreaRule", "CompositeRule" };
LayerLegendInfo layerInfo = new LayerLegendInfo { Name = layer.Name, Label = layer.LegendLabel, Path = layer.LayerDefinition.ToString() };
string xmlContent = resourceService.GetResourceContent(layer.LayerDefinition).ToString();
XmlDocument doc = new XmlDocument();
doc.LoadXml(xmlContent);
XmlNodeList scaleNodes = doc.GetElementsByTagName("VectorScaleRange");
foreach (XmlElement scaleRange in scaleNodes)
{
double minScale = 0.0;
double maxScale = 1000000000000.0;
XmlNode minScaleNode = scaleRange.SelectSingleNode("MinScale");
XmlNode maxScaleNode = scaleRange.SelectSingleNode("MaxScale");
if (minScaleNode != null) minScale =Convert.ToDouble(minScaleNode.InnerText);
if (maxScaleNode != null) maxScale = Convert.ToDouble(maxScaleNode.InnerText);
if (scale > minScale && scale < maxScale)
{
for (int stylesIndex = 0; stylesIndex < styleTypes.Length; stylesIndex++)
{
foreach (XmlElement element in (scaleRange).GetElementsByTagName(styleTypes[stylesIndex]))
{
int legendIndex = -1;
foreach (XmlElement rule in element.GetElementsByTagName(ruleNames[stylesIndex]))
{
string legendLabel = rule.SelectSingleNode("LegendLabel").InnerText;
if (string.IsNullOrEmpty(legendLabel)) continue;
LayerLegendInfo info = new LayerLegendInfo { Label = HttpUtility.HtmlAttributeEncode(legendLabel), Path = layerInfo.Path, GeomType = stylesIndex + 1, LegendIndex = ++legendIndex };
layerInfo.Children.Add(info);
}
insertInToList = true;
}
}
break;
}
}
return insertInToList ? layerInfo : null;
//return layerInfo;
}
protected void Page_Load(object sender, EventArgs e)
{
if (!Page.IsPostBack)
{
string sessionId = GetRequestParameters(Request)["SESSION"];
string mapName = GetRequestParameters(Request)["MAPNAME"];
string locale = GetRequestParameters(Request)["LOCALE"];
if (string.IsNullOrEmpty(sessionId))
{
Response.Clear();
Response.End();
return;
}
if (string.IsNullOrEmpty(mapName))
{
Response.Clear();
Response.End();
return;
}
MgResourceService resourceSrvc = GetMgResurceService(sessionId);
MgFeatureService featureSrvc = GetMgFeatureService(sessionId);
MgMap map = new MgMap();
map.Open(resourceSrvc, mapName);
string layernames = GetRequestParameters(Request)["LAYERNAMES"];
string GEOMETRY = GetRequestParameters(Request)["GEOMETRY"];
string selVar = GetRequestParameters(Request)["SELECTIONVARIANT"];
string type = GetRequestParameters(Request)["tp"];
string inputSel = GetRequestParameters(Request)["SELECTION"];
bool hasInputGeom = false;
if (!string.IsNullOrEmpty(GEOMETRY))
{
hasInputGeom = true;
}
//selection ima prednost pred podano geometrijo ...
MgWktReaderWriter wktrw = new MgWktReaderWriter();
if (!string.IsNullOrEmpty(inputSel))
{
MgGeometry inputGeom = MultiGeometryFromSelection(featureSrvc, map, inputSel);
GEOMETRY = wktrw.Write(inputGeom);
}
MgAgfReaderWriter agfRW = new MgAgfReaderWriter();
int nLayer = 0;
// pobrišem in zgradim na novo samo tiste, ki imajo zadetke ...
int nSloj = 0;
string filter = "";
StringBuilder sbOut = new StringBuilder();
sbOut.Append("<table width=\"100%\" class=\"results\">");
sbOut.Append("<tr><td class='header'></td><td class='header'>" + "Layer" + "</td><td class='header' align=\"center\">" + "Select" + "</td><td class='header' align=\"center\">" + "Report" + "</td></tr>");
MgSelection selAll = new MgSelection(map);
foreach (MgLayer layer in map.GetLayers())
{
if (type != "2")
{
if (!layer.IsVisible())
{
goto nextlay;
}
}
if (layer.LegendLabel == "")
{
goto nextlay;
}
try
{
nLayer++;
filter = String.Format("{0} {1} GeomFromText('{2}')", layer.GetFeatureGeometryName(), selVar, GEOMETRY);
//preveriti še filter na Layerju. Ker ne gre drugače, je potrebno pogledati v XML
MgResourceIdentifier layerDefResId = layer.GetLayerDefinition();
MgByteReader byteReader = resourceSrvc.GetResourceContent(layerDefResId);
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
String xmlLayerDef = byteReader.ToString();
doc.LoadXml(xmlLayerDef);
KALI.MGE.Objects.KALILayerDefinition.LayerDefinition ld = KALI.MGE.Objects.KALILayerDefinition.LayerDefinition.Parse(xmlLayerDef);
if (!string.IsNullOrEmpty(ld.VectorLayerDefinition.Filter))
{
filter += " AND (" + ld.VectorLayerDefinition.Filter + ")";
}
//query the features
MgFeatureQueryOptions opts = new MgFeatureQueryOptions();
opts.SetFilter(filter);
String featureClassName = layer.GetFeatureClassName();
MgResourceIdentifier srcId = new MgResourceIdentifier(layer.GetFeatureSourceId());
MgFeatureReader features = featureSrvc.SelectFeatures(srcId, featureClassName, opts);
bool hasResult = features.ReadNext();
if (hasResult)
{
nSloj++;
int n = 0;
MgClassDefinition classDef = features.GetClassDefinition();
MgPropertyDefinitionCollection classDefProps = classDef.GetIdentityProperties();
ArrayList idPropNames = new ArrayList(classDefProps.GetCount());
for (int j = 0; j < classDefProps.GetCount(); j++)
{
MgPropertyDefinition idProp = classDefProps.GetItem(j);
idPropNames.Add(idProp.GetName());
}
MgSelection sel = new MgSelection(map);
do
{
// Generate XML to selection this feature
MgPropertyCollection idProps = new MgPropertyCollection();
foreach (string id in idPropNames)
{
int idPropType = features.GetPropertyType(id);
switch (idPropType)
{
case MgPropertyType.Int32:
idProps.Add(new MgInt32Property(id, features.GetInt32(id)));
break;
case MgPropertyType.String:
idProps.Add(new MgStringProperty(id, features.GetString(id)));
break;
case MgPropertyType.Int64:
idProps.Add(new MgInt64Property(id, features.GetInt64(id)));
break;
case MgPropertyType.Double:
idProps.Add(new MgDoubleProperty(id, features.GetDouble(id)));
break;
case MgPropertyType.Single:
idProps.Add(new MgSingleProperty(id, features.GetSingle(id)));
break;
case MgPropertyType.DateTime:
idProps.Add(new MgDateTimeProperty(id, features.GetDateTime(id)));
break;
default:
//throw new SearchError(String.Format(MgLocalizer.GetString("SEARCHTYYPENOTSUP", locale), new Object[] { idPropType.ToString() }), searchError);
break;
}
}
sel.AddFeatureIds(layer, featureClassName, idProps);
selAll.AddFeatureIds(layer, featureClassName, idProps);
n++;
//if (n > 1000) break;
} while (features.ReadNext());
features.Close();
features.Dispose();
string selText = EscapeForHtml(sel.ToXml());
string seljs = "<div class=\"allLay\" onclick=\"parent.SetSelectionXML('" + selText + "');\"><img width=\"16\" height=\"16\" style=\"border:0\" src=\"images/mActionZoomToSelected.png\"/></div>";
string seljs3 = "<div class=\"allLay\" onclick=\"parent.MultiGridShow('" + selText + "');\"><img width=\"16\" height=\"16\" style=\"border:0\" src=\"images/mActionOpenTable.png\"/></div>";
string linfo = "<b>" + layer.LegendLabel + "</b><br />" + n.ToString() + " " + "Hits";
sbOut.Append("<tr><td class=\"results\">" + nSloj.ToString() + "</td><td class=\"results\">" + linfo + "</td><td align=\"center\" class=\"results\">" + seljs + "</td><td align=\"center\" class=\"results\">" + seljs3 + "</td></tr>");
}
}
catch (Exception)
{
continue;
}
nextlay:
continue;
}
sbOut.Append("</table>");
string selAllText = EscapeForHtml(selAll.ToXml());
string seljsAll = "<div class=\"allLay\" onclick=\"parent.SetSelectionXML('" + selAllText + "');\"><img width=\"16\" height=\"16\" style=\"border:0\" src=\"images/mActionZoomToSelected.png\"/>" + "Select All" + "</div>";
string seljsAll3 = "<div class=\"allLay\" onclick=\"parent.MultiGridShow('" + selAllText + "');\"><img width=\"16\" height=\"16\" style=\"border:0\" src=\"images/mActionOpenTable.png\"/>" + "Report All" + "</div>";
sbOut.Append(string.Format("<br /><table width=\"100%\" class=\"results\"><tr><td class=\"results\">{0}</td><td class=\"results\">{1}</td></tr></table>", seljsAll, seljsAll3));
featureSrvc.Dispose();
resourceSrvc.Dispose();
if (nSloj > 0)
{
litPrebodi.Text = sbOut.ToString();
}
else
{
litPrebodiTitle.Visible = false;
litPrebodi.Text = "<b>" + "None layer lies below the selected item/area!" + "</b>";
}
MgGeometry inGeom = wktrw.Read(GEOMETRY);
double rw = map.ViewScale / Math.Sqrt(inGeom.Area);
//koordinate
if (hasInputGeom & rw > 400)
{
string output = "";
output = pointTransformAndWriteZ(GEOMETRY, map);
litKoordinate.Text = output;
litKoordinateTitle.Text = "Coordinates of selected points:";
}
}
}
