public ElementData Style(string name, string value)
{
if (name == null)
{
return(this);
}
name = name.Trim();
value = value.Trim();
// Trim a trailing semicolon, it'll be inserted later
if (value.EndsWith(";"))
{
value = value.Substring(0, value.Length - 1);
}
if (value == null && Styles.ContainsKey(name))
{
return(new ElementData(this, styles: Styles.Remove(name)));
}
if (value != null)
{
return(new ElementData(this, styles: Styles.SetItem(name, value)));
}
return(this);
}
public virtual void SetStyle(string name, string value)
{
if (Styles.ContainsKey(name))
{
Styles[name] = value;
}
else
{
Styles.Add(name, value);
}
}
/// <summary>
/// Appends a data set to an existing data set.
/// </summary>
/// <param name="data">Data set to append</param>
public void Append(SpatialDataSet data)
{
if (data != null)
{
BoundingBox = data.BoundingBox.Join(BoundingBox);
Geometries.AddRange(data.Geometries);
if (data.Styles != null && data.Styles.Count > 0)
{
if (Styles == null)
{
Styles = data.Styles;
}
else
{
foreach (var key in data.Styles.Keys)
{
if (!Styles.ContainsKey(key))
{
Styles.Add(key, data.Styles[key]);
}
}
}
}
if (!Metadata.HasMetadata())
{
Metadata = data.Metadata;
}
if (!string.IsNullOrEmpty(data.Error))
{
if (string.IsNullOrEmpty(Error))
{
Error = data.Error;
}
else
{
Error += "\r\n" + data.Error;
}
}
}
}
/// <summary>
/// Goes through all the styles and removes duplicates.
/// </summary>
public void CleanUpStyles()
{
if (Styles != null && Geometries != null)
{
//key = old style key, value = new style key
var styleMap = new Dictionary <string, string>();
//Find duplicate styles
foreach (var s in Styles)
{
foreach (var s2 in Styles)
{
//Ensure different key and that key isn't already marked to be removed.
if (string.Compare(s.Key, s2.Key) != 0 && !styleMap.ContainsKey(s.Key))
{
if (s.Value.Equals(s2.Value))
{
styleMap.Add(s2.Key, s.Key);
}
}
}
}
//Update style keys on Geometries
foreach (var g in Geometries)
{
if (styleMap.ContainsKey(g.StyleKey))
{
g.StyleKey = styleMap[g.StyleKey];
}
}
//Remove old styles
foreach (var s in styleMap)
{
if (Styles.ContainsKey(s.Key))
{
Styles.Remove(s.Key);
}
}
}
}
bool IDictionary <string, string> .ContainsKey(string key)
{
return(HasStyleAttribute ?
Styles.ContainsKey(HtmlData.Tokenize(key)) :
false);
}
/// <summary>
/// Returns true if the named style is defined
/// </summary>
/// <param name="styleName"></param>
/// <returns></returns>
public bool HasStyle(string styleName)
{
return(HasStyleAttribute ?
Styles.ContainsKey(HtmlData.Tokenize(styleName)) :
false);
}
private void dataAddedWorker_DoWork(object sender, DoWorkEventArgs args)
{
var worker = sender as BackgroundWorker;
//going to modify the list so can't use a foreach.
while (true)
{
if (layerDataToProcess.Count == 0)
{
break;
}
VectorLayerData vectorLayerData = layerDataToProcess[0];
if (worker != null && worker.CancellationPending)
{
args.Cancel = true;
break;
}
StyleSpecification style = Styles[cDefaultStyleID];
string styleID = (!string.IsNullOrEmpty(vectorLayerData.Style))
? vectorLayerData.Style
: LayerDefinition.LayerStyleName;
if (Styles.ContainsKey(styleID))
{
style = Styles[styleID];
}
var wkbReader = new WKBReader(new GeometryFactory(new PrecisionModel(), 4326));
try
{
IGeometry geo = wkbReader.Read(vectorLayerData.Geo);
VectorLayerData data = vectorLayerData;
Dispatcher.BeginInvoke(delegate
{
var infogeo = new InfoGeometry(geo, style, MapInstance, this)
{
Label = data.Label,
LabelVisibility =
(LayerDefinition.LabelOn)
? Visibility.Visible
: Visibility.Collapsed,
ItemID = data.ID,
EnableBalloon = EnableBalloon,
EnableSelection = EnableSelection,
TimeStamp = data.TimeStamp,
};
infogeo.Balloon += (o, e) =>
{
if (
((InfoGeometry)o).BalloonData.Count ==
0)
{
Commands.LoadBalloonDataCommand.Execute(e, o);
}
};
infogeo.Selected += (o, e) => Commands.ItemSelectedCommand.Execute(o);
if (LayerDefinition.PermissionToEdit)
{
infogeo.Selected += (o, e) => Commands.EditVectorCommand.Execute(o);
}
mapLayerGeometries.Add(infogeo);
});
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
}
layerDataToProcess.Remove(vectorLayerData);
}
}
bool IDictionary <string, string> .ContainsKey(string key)
{
return(Styles.ContainsKey(HtmlData.Tokenize(key)));
}
/// <summary>
/// Returns true if the named style is defined
/// </summary>
/// <param name="styleName"></param>
/// <returns></returns>
public bool HasStyle(string styleName)
{
return(Styles.ContainsKey(HtmlData.Tokenize(styleName)));
}
private void process()
{
string startUbb = string.Empty, endUbb = string.Empty;
if (Styles.ContainsKey("color"))
{
startUbb += "[color=" + Styles["color"] + "]";
startUbb = Util.ConvertRGB(startUbb);
endUbb = "[/color]" + endUbb;
}
if (Styles.ContainsKey("font-size"))
{
string size = Styles["font-size"].ToString();
startUbb += "[size=" + (mapSize.ContainsKey(size) ? mapSize[size].ToString() : size) + "]";
endUbb = "[/size]" + endUbb;
}
if (Styles.ContainsKey("font-family"))
{
startUbb += "[font=" + Styles["font-family"] + "]";
endUbb = "[/font]" + endUbb;
}
if (Styles.ContainsKey("font-style"))
{
string fontStyle = Styles["font-style"] + "";
if (fontStyle == "italic")
{
startUbb += "[i]";
endUbb = "[/i]" + endUbb;
}
}
if (Styles.ContainsKey("font-weight"))
{
string fontWeight = Styles["font-weight"] + "";
if (fontWeight != "normal")
{
startUbb += "[b]";
endUbb = "[/b]" + endUbb;
}
}
if (Styles.ContainsKey("text-decoration"))
{
string dec = Styles["text-decoration"] + "";
if (dec == "underline")
{
startUbb += "[u]";
endUbb = "[/u]" + endUbb;
}
else if (dec == "line-through")
{
startUbb += "[s]";
endUbb = "[/s]" + endUbb;
}
}
if (Styles.ContainsKey("text-align"))
{
string align = Styles["text-align"].ToString();
if (align == "left" || align == "right" || align == "center")
{
startUbb += "[align=" + align + "]";
endUbb = "[/align]" + endUbb;
}
}
if (Styles.ContainsKey("background-color"))
{
startUbb += "[bgcolor=" + Styles["background-color"] + "]";
startUbb = Util.ConvertRGB(startUbb);
endUbb = "[/bgcolor]" + endUbb;
}
_startUbb = startUbb;
_endUbb = endUbb;
}
public HtmlTagBase(int index, string tagHtml, int begin)
{
Index = index;
Html = tagHtml;
bool hasAttribute = false;
this.Begin = begin;
this.End = this.Begin + Html.Length;
if (StringUtil.EndsWith(tagHtml, "/>"))
{
IsSingleTag = true;
}
if (StringUtil.StartsWith(tagHtml, "</"))
{
IsEndTag = true;
}
tagHtml = tagHtml.Remove(0, IsEndTag ? 2 : 1);
tagHtml = tagHtml.Remove(tagHtml.Length - (IsSingleTag ? 2 : 1), IsSingleTag ? 2 : 1);
if (tagHtml.Contains(" "))
{
this.TagName = tagHtml.Substring(0, tagHtml.IndexOf(' '));
hasAttribute = true;
}
else
{
this.TagName = tagHtml;
}
this.TagName = this.TagName.ToLower();
if (hasAttribute)
{
tagHtml = tagHtml.Remove(0, TagName.Length);
tagHtml = tagHtml.Trim();
string[] attributes = regAttrSplite.Split(tagHtml);
foreach (string s in attributes)
{
if (s.Contains("=") && s.Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries).Length > 1)
{
string[] temp = new string[] { string.Empty, string.Empty };//
int sIndex = s.IndexOf('=');
temp[0] = s.Substring(0, sIndex);
if (s.Length > sIndex)
{
temp[1] = s.Substring(sIndex + 1);
}
//s.Split(new char[] { '=' }, StringSplitOptions.RemoveEmptyEntries);
string key = temp[0].Trim().ToLower();
if (!Attributes.ContainsKey(key))
{
Attributes.Add(key, temp[1].Trim('\"', ' '));
}
}
}
if (Attributes.ContainsKey("style"))
{
string[] styleSet = (Attributes["style"] + "").Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries);
foreach (string s in styleSet)
{
string[] styleItem = s.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries);
if (styleItem.Length == 2)
{
string key = styleItem[0].Trim().ToLower();
if (!Styles.ContainsKey(key))
{
Styles.Add(key, styleItem[1].Trim());
}
}
}
}
}
//if (IsSingleTag && Attributes.Count == 0)
//{
// IsEndTag = true;
//}
if (!IsSingleTag)
{
IsSingleTag =
TagName == "img" ||
TagName == "br" ||
TagName == "hr" ||
TagName == "input" ||
TagName == "param" ||
TagName == "meta" ||
TagName == "link";
}
}
bool IDictionary <string, string> .ContainsKey(string key)
{
return(Styles.ContainsKey(DomData.TokenID(key, true)));
}
/// <summary>
/// Returns true if the named style is defined
/// </summary>
/// <param name="styleName"></param>
/// <returns></returns>
public bool HasStyle(string styleName)
{
return(Styles.ContainsKey(DomData.TokenID(styleName, true)));
}
public void Load(Stream stream)
{
string expression = ReadStream(stream);
String[] expressions = expression.Split('}');
foreach (String s1 in expressions)
{
String expr = s1.Trim();
if (!String.IsNullOrEmpty(expr))
{
String[] arr = expr.Split('{');
if (arr.Length != 2)
{
throw new Exception(String.Format("Css error: ", expr));
}
String selector = arr[0].Trim().ToLower();
String[] sel = selector.Split(' ');
selector = "";
foreach (String selPart in sel)
{
String ss = selPart.Trim();
if (!String.IsNullOrEmpty(ss))
{
if (tagNames.ContainsKey(ss))
{
ss = tagNames[ss].Name.ToLower();
}
if (!String.IsNullOrEmpty(selector))
{
selector += " ";
}
selector += ss;
}
}
foreach (String s2 in arr[1].Split(';'))
{
String style = s2.Trim();
if (!String.IsNullOrEmpty(style))
{
String[] arr2 = style.Split(':');
if (arr2.Length != 2)
{
throw new Exception(String.Format("Css error: ", style));
}
String attr = arr2[0].Trim();
String value = arr2[1].Trim();
if (!styleNames.ContainsKey(attr))
{
throw new Exception(String.Format("Style {0} is not found", attr));
}
Type attrType = styleNames[attr];
Style s = (Style)attrType.GetConstructor(new Type[] { }).Invoke(new object[] { });
s = s.FromString(value);
if (!Styles.ContainsKey(selector))
{
Styles.Add(selector, new List <Style>());
}
Styles[selector].Add(s);
}
}
}
}
}