private Theme GetTheme(ThemeCategory category)
{
string key;
if (category == ThemeCategory.App)
{
key = "AppsUseLightTheme";
}
else // (category == ThemeCategory.System)
{
key = "SystemUsesLightTheme";
}
try
{
RegistryKey registryKey = Registry.Users;
RegistryKey subKey = registryKey.CreateSubKey(wmiRegistryPath);
int result = (int)subKey.GetValue(key);
return((Theme)result);
}
catch (Exception e)
{
Console.WriteLine("Error reading key!");
Console.WriteLine(e);
return(Theme.Dark);
}
}
private void SetRegistryTheme(ThemeCategory category, Theme theme)
{
String key;
if (category == ThemeCategory.System)
{
key = "SystemUsesLightTheme";
}
else if (category == ThemeCategory.App)
{
key = "AppsUseLightTheme";
}
else
{
throw new Exception("Invalid theme category!");
}
try
{
RegistryKey registryKey = Registry.Users;
RegistryKey subKey = registryKey.CreateSubKey(wmiRegistryPath);
subKey.SetValue(key, (int)theme);
}
catch (Exception e)
{
Console.WriteLine("Error writing key!");
Console.WriteLine(e);
}
}
public PanelBase CreatePanel(ThemeCategory category)
{
switch (category)
{
case ThemeCategory.Themes:
Controller.Part = ThemePart.Category;
return(AddUIComponent <SelectThemePanel>());
case ThemeCategory.Terrain:
return(AddUIComponent <CategoryPanels.TerrainPanel>());
case ThemeCategory.Water:
return(AddUIComponent <CategoryPanels.WaterPanel>());
case ThemeCategory.Structures:
return(AddUIComponent <StructuresPanel>());
case ThemeCategory.Weather:
return(AddUIComponent <WeatherPanel>());
case ThemeCategory.Atmosphere:
return(AddUIComponent <AtmospherePanel>());
case ThemeCategory.Mixes:
return(AddUIComponent <MixesPanel>());
case ThemeCategory.None:
return(AddUIComponent <LutsPanel>());
default: return(null);
}
}
public ListItem(string id, string displayName, string author, bool isFavourite, bool isBlacklisted, ThemeCategory category)
{
ID = id;
DisplayName = displayName;
Author = author;
IsFavourite = isFavourite;
IsBlacklisted = isBlacklisted;
Category = category;
}
public void changeCateogry(ThemeCategory category)
{
if (category == ThemeCategory.transitions)
{
comboBoxCategory.SelectedIndex = 0;
}
if (category == ThemeCategory.precursors)
{
comboBoxCategory.SelectedIndex = 1;
}
}
public static string GetCategoryAndPartLabel(ThemeCategory category, ThemePart part)
{
string prefix = string.Concat(Translation.Instance.GetTranslation(TranslationID.LABEL_SELECT), " ");
string text = string.Empty;
switch (category)
{
case ThemeCategory.Themes:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_THEME);
break;
case ThemeCategory.Terrain:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_TERRAIN);
break;
case ThemeCategory.Water:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_WATER);
break;
case ThemeCategory.Structures:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_STRUCTURES);
break;
case ThemeCategory.Atmosphere:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_ATMOSPHERE);
break;
case ThemeCategory.Weather:
text = Translation.Instance.GetTranslation(TranslationID.LABEL_WEATHER);
break;
}
string postFix = string.Empty;
switch (part)
{
case ThemePart.Texture:
postFix = string.Concat(" ", Translation.Instance.GetTranslation(TranslationID.LABEL_TEXTURE));
break;
case ThemePart.Color:
postFix = string.Concat(" ", Translation.Instance.GetTranslation(TranslationID.LABEL_COLOR));
break;
case ThemePart.Offset:
postFix = string.Concat(" ", Translation.Instance.GetTranslation(TranslationID.LABEL_OFFSET));
break;
case ThemePart.Value:
postFix = string.Concat(" ", Translation.Instance.GetTranslation(TranslationID.LABEL_VALUE));
break;
}
return(string.Concat(prefix, text, postFix));
}
public ToolbarButton(ThemeCategory part, UIComponent parent)
{
Category = part;
string icon;
string locale;
switch (part)
{
case ThemeCategory.Themes:
icon = UISprites.ThemesIcon;
locale = TranslationID.TOOLTIP_THEMES;
break;
case ThemeCategory.Terrain:
icon = UISprites.TerrainIcon;
locale = TranslationID.TOOLTIP_TERRAIN;
break;
case ThemeCategory.Water:
icon = UISprites.WaterIcon;
locale = TranslationID.TOOLTIP_WATER;
break;
case ThemeCategory.Structures:
icon = UISprites.StructuresIcon;
locale = TranslationID.TOOLTIP_STRUCTURES;
break;
case ThemeCategory.Atmosphere:
icon = UISprites.AtmosphereIcon;
locale = TranslationID.TOOLTIP_ATMOSPHERE;
break;
case ThemeCategory.Weather:
icon = UISprites.WeatherIcon;
locale = TranslationID.TOOLTIP_WEATHER;
break;
case ThemeCategory.Mixes:
icon = UISprites.SettingsIcon;
locale = TranslationID.TOOLTIP_MIXES;
break;
default:
icon = UISprites.LutIcon;
locale = TranslationID.TOOLTIP_LUTS;
break;
}
Button = UIUtils.CreateButton(parent, ButtonSize, foregroundSprite: UISprites.IconBorder, backgroundSprite: icon, atlas: UISprites.Atlas, isFocusable: true, tooltip: Translation.Instance.GetTranslation(locale));
Button.eventClicked += OnButtonClicked;
}
private void UpdateThemeIfNecessary(ThemeCategory category, Theme theme)
{
if (category == ThemeCategory.App && theme != currentAppTheme)
{
currentAppTheme = theme;
UpdateDisplayTheme();
SetRegistryTheme(ThemeCategory.App, theme);
}
if (category == ThemeCategory.System && theme != currentSystemTheme)
{
currentSystemTheme = theme;
UpdateDisplayTheme();
SetRegistryTheme(ThemeCategory.System, theme);
}
}
private void HandleQuickSwitchCategoryCheckbox(ThemeCategory category)
{
if (category == ThemeCategory.System)
{
bool currentValue = systemChangeQuickSwitch.Checked;
Settings.Default.QuickSwitchChangesSystem = !currentValue;
systemChangeQuickSwitch.Checked = !currentValue;
}
else if (category == ThemeCategory.App)
{
bool currentValue = appChangeQuickSwitch.Checked;
Settings.Default.QuickSwitchChangesApp = !currentValue;
appChangeQuickSwitch.Checked = !currentValue;
}
Settings.Default.Save();
QuickSwitchTheme(currentDisplayTheme);
EvaluateQuickSwitchEligibility();
}
public void LoadCategory(ThemeCategory category, string themeID)
{
switch (category)
{
case ThemeCategory.Themes: CurrentMix = new ThemeMix(themeID); break;
case ThemeCategory.Terrain: CurrentMix.Terrain.Load(themeID); break;
case ThemeCategory.Water: CurrentMix.Water.Load(themeID); break;
case ThemeCategory.Structures: CurrentMix.Structures.Load(themeID); break;
case ThemeCategory.Atmosphere: CurrentMix.Atmosphere.Load(themeID); break;
case ThemeCategory.Weather: CurrentMix.Weather.Load(themeID); break;
}
SaveLocalMix();
EventUIDirty?.Invoke(this, new UIDirtyEventArgs(CurrentMix));
}
public bool IsSelected(string themeID, ThemeCategory category)
{
switch (category)
{
case ThemeCategory.Themes: return(CurrentMix.IsSelected(themeID));
case ThemeCategory.Atmosphere: return(CurrentMix.Atmosphere.IsSelected(themeID));
case ThemeCategory.Structures: return(CurrentMix.Structures.IsSelected(themeID));
case ThemeCategory.Terrain: return(CurrentMix.Terrain.IsSelected(themeID));
case ThemeCategory.Water: return(CurrentMix.Water.IsSelected(themeID));
case ThemeCategory.Weather: return(CurrentMix.Weather.IsSelected(themeID));
default: return(false);
}
}
private void HandleSunsetCategoryCheckbox(ThemeCategory category)
{
bool checkRemoved = false;
if (category == ThemeCategory.System)
{
bool currentValue = systemChangeSunset.Checked;
Settings.Default.SunsetChangesSystem = !currentValue;
systemChangeSunset.Checked = !currentValue;
checkRemoved = currentValue;
}
else if (category == ThemeCategory.App)
{
bool currentValue = appChangeSunset.Checked;
Settings.Default.SunsetChangesApp = !currentValue;
appChangeSunset.Checked = !currentValue;
checkRemoved = currentValue;
}
Settings.Default.Save();
if (!checkRemoved)
{
UpdateThemeIfNecessary(category, lastSunState ? Theme.Light : Theme.Dark);
}
}
internal static bool ScaleIsApplicable(double scale, ThemeCategory cat)
{
bool bApplicable = false;
bool bHasMin = !string.IsNullOrEmpty(cat.MinScale);
bool bHasMax = !string.IsNullOrEmpty(cat.MaxScale);
if (bHasMin)
{
double minVal = double.Parse(cat.MinScale, CultureInfo.InvariantCulture);
if (bHasMax) //bHasMin = true, bHasMax = true
{
double maxVal = double.Parse(cat.MaxScale, CultureInfo.InvariantCulture);
if (scale >= minVal && scale < maxVal)
bApplicable = true;
}
else //bHasMin = true, bHasMax = false
{
if (scale >= minVal)
bApplicable = true;
}
}
else
{
if (bHasMax) //bHasMin = false, bHasMax = true
{
double maxVal = double.Parse(cat.MaxScale, CultureInfo.InvariantCulture);
if (scale < maxVal)
bApplicable = true;
}
else //bHasMin = false, bHasMax = false
{
bApplicable = true;
}
}
return bApplicable;
}
public ThemeSelectedEventArgs(string themeID, ThemeCategory category, ThemePart part)
{
ThemeID = themeID;
Category = category;
Part = part;
}
public ThemesPanelClosingEventArgs(ThemeCategory category, ThemePart part)
{
Category = category;
Part = part;
}
private TreeNode CreateCompressedThemeNode(LayerNodeMetadata layer, ThemeCategory cat, int count)
{
TreeNode node = new TreeNode();
node.Text = (count + " other styles");
node.ImageKey = node.SelectedImageKey = IMG_OTHER;
var meta = new LayerThemeNodeMetadata(true, Properties.Resources.icon_etc, node.Text);
node.Tag = meta;
layer.AddThemeNode(cat, meta);
return node;
}
public ThemeDirtyEventArgs(ThemeCategory category, ThemePart part, IMixable loadable = null)
{
Loadable = loadable;
Category = category;
Part = part;
}
private TreeNode CreateLayerNode(RuntimeMapLayer layer)
{
var node = new TreeNode();
node.Name = layer.ObjectId;
node.Text = layer.LegendLabel;
node.Checked = layer.Visible;
//node.ContextMenuStrip = _legend.LayerContextMenu;
var lt = layer.Type;
var fsId = layer.FeatureSourceID;
LayerNodeMetadata layerMeta = null;
if (fsId.EndsWith("DrawingSource"))
{
node.SelectedImageKey = node.ImageKey = IMG_DWF;
bool bInitiallySelectable = layer.Selectable;
if (_layers.ContainsKey(layer.ObjectId))
{
layerMeta = _layers[layer.ObjectId];
bInitiallySelectable = layerMeta.WasInitiallySelectable;
}
else //If not in the dictionary, assume it is a dynamically added layer
{
RuntimeMapGroup group = null;
if (!string.IsNullOrEmpty(layer.Group))
group = _map.Groups[layer.Group];
layerMeta = new LayerNodeMetadata(layer, bInitiallySelectable);
_layers[layer.ObjectId] = layerMeta;
}
node.Tag = layerMeta;
node.ToolTipText = string.Format(Properties.Resources.DrawingLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID);
}
else //Vector or Grid layer
{
var ldfId = layer.LayerDefinitionID;
if (_layers.ContainsKey(layer.ObjectId))
{
layerMeta = _layers[layer.ObjectId];
}
else
{
RuntimeMapGroup group = null;
if (!string.IsNullOrEmpty(layer.Group))
group = _map.Groups[layer.Group];
layerMeta = new LayerNodeMetadata(layer, layer.Selectable);
_layers[layer.ObjectId] = layerMeta;
}
if (string.IsNullOrEmpty(layerMeta.LayerDefinitionContent))
return null;
node.Tag = layerMeta;
const int LAYER_VECTOR = 0;
const int LAYER_RASTER = 1;
const int LAYER_DWF = 2;
XmlDocument doc = new XmlDocument();
doc.LoadXml(layerMeta.LayerDefinitionContent);
int type = LAYER_VECTOR;
XmlNodeList scaleRanges = doc.GetElementsByTagName("VectorScaleRange");
if (scaleRanges.Count == 0)
{
scaleRanges = doc.GetElementsByTagName("GridScaleRange");
if (scaleRanges.Count == 0)
{
scaleRanges = doc.GetElementsByTagName("DrawingLayerDefinition");
if (scaleRanges.Count == 0)
return null;
type = LAYER_DWF;
}
else
type = LAYER_RASTER;
}
String[] typeStyles = new String[] { "PointTypeStyle", "LineTypeStyle", "AreaTypeStyle", "CompositeTypeStyle" };
String[] ruleNames = new String[] { "PointRule", "LineRule", "AreaRule", "CompositeRule" };
node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName);
//Do this if not cached already from a previous run
if (!layerMeta.HasTheme() || !layerMeta.HasDefaultIcons())
{
for (int sc = 0; sc < scaleRanges.Count; sc++)
{
XmlElement scaleRange = (XmlElement)scaleRanges[sc];
XmlNodeList minElt = scaleRange.GetElementsByTagName("MinScale");
XmlNodeList maxElt = scaleRange.GetElementsByTagName("MaxScale");
String minScale, maxScale;
minScale = "0";
maxScale = "1000000000000.0"; // as MDF's VectorScaleRange::MAX_MAP_SCALE
if (minElt.Count > 0)
minScale = minElt[0].ChildNodes[0].Value;
if (maxElt.Count > 0)
maxScale = maxElt[0].ChildNodes[0].Value;
if (type != LAYER_VECTOR)
break;
bool bComposite = false;
//Check TS count. Give precedence to composite type styles
List<XmlNode> typeStyleCol = new List<XmlNode>();
XmlNodeList styleNodes = scaleRange.GetElementsByTagName(typeStyles[3]);
List<RuleData> rules = new List<RuleData>();
if (styleNodes.Count > 0)
{
foreach (XmlNode n in styleNodes)
{
// We will check if this typestyle is going to be shown in the legend
XmlNodeList showInLegend = ((XmlElement)n).GetElementsByTagName("ShowInLegend"); //NOXLATE
if (showInLegend.Count > 0)
if (!bool.Parse(showInLegend[0].ChildNodes[0].Value))
continue; // This typestyle does not need to be shown in the legend
typeStyleCol.Add(n);
var ruleData = new RuleData();
ruleData.GeomType = 3;
ruleData.RuleNodes = ((XmlElement)n).GetElementsByTagName(ruleNames[3]);
if (ruleData.RuleNodes.Count > 0)
rules.Add(ruleData);
}
bComposite = true;
}
else
{
for (int t = 0; t < 3; t++)
{
styleNodes = scaleRange.GetElementsByTagName(typeStyles[t]);
foreach (XmlNode n in styleNodes)
{
// We will check if this typestyle is going to be shown in the legend
XmlNodeList showInLegend = ((XmlElement)n).GetElementsByTagName("ShowInLegend"); //NOXLATE
if (showInLegend.Count > 0)
if (!bool.Parse(showInLegend[0].ChildNodes[0].Value))
continue; // This typestyle does not need to be shown in the legend
typeStyleCol.Add(n);
var ruleData = new RuleData();
ruleData.GeomType = t;
ruleData.RuleNodes = ((XmlElement)n).GetElementsByTagName(ruleNames[t]);
if (ruleData.RuleNodes.Count > 0)
rules.Add(ruleData);
}
}
}
//No type styles. Skip
if (typeStyleCol.Count == 0)
continue;
//Determine if this is themed or not
int nTotalRules = 0;
foreach (RuleData r in rules)
{
nTotalRules += r.RuleNodes.Count;
}
bool bThemed = nTotalRules > 1;
if (bThemed)
{
int catIndex = 0;
for (int i = 0; i < rules.Count; i++)
{
RuleData theRule = rules[i];
ThemeCategory themeCat = new ThemeCategory()
{
MinScale = minScale,
MaxScale = maxScale,
GeometryType = theRule.GeomType
};
//Non-composite styles must be processed once
if (layerMeta.CategoryExists(themeCat) && theRule.GeomType != 3)
continue;
layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_theme);
node.ToolTipText = string.Format(Properties.Resources.ThemedLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName, nTotalRules);
if (_legend.ThemeCompressionLimit > 0 && theRule.RuleNodes.Count > _legend.ThemeCompressionLimit)
{
AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, catIndex, theRule.RuleNodes, 0);
node.Nodes.Add(CreateCompressedThemeNode(layerMeta, themeCat, theRule.RuleNodes.Count - 2));
AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, (catIndex + (theRule.RuleNodes.Count - 1)), theRule.RuleNodes, theRule.RuleNodes.Count - 1);
}
else
{
for (int r = 0; r < theRule.RuleNodes.Count; r++)
{
AddThemeRuleNode(layerMeta, themeCat, node, theRule.GeomType, (catIndex + r), theRule.RuleNodes, r);
}
}
//Only bump catIndex if composite, as category indexes for composite styles are handled differently
if (bComposite)
catIndex += theRule.RuleNodes.Count;
}
}
else
{
Trace.Assert(rules.Count == 1);
Trace.Assert(rules[0].RuleNodes.Count == 1);
RuleData theRule = rules[0];
ThemeCategory themeCat = new ThemeCategory()
{
MinScale = minScale,
MaxScale = maxScale,
GeometryType = theRule.GeomType
};
if (layerMeta.CategoryExists(themeCat))
continue;
if (LayerNodeMetadata.ScaleIsApplicable(_map.ViewScale, themeCat))
{
if (!layerMeta.HasDefaultIconsAt(_map.ViewScale))
{
try
{
var img = _map.GetLegendImage(layer.LayerDefinitionID,
_map.ViewScale,
16,
16,
"PNG",
(theRule.GeomType + 1),
-1);
legendCallCount++;
layerMeta.SetDefaultIcon(themeCat, img);
node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName);
}
catch
{
//layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_broken);
}
}
}
}
//for (int geomType = 0; geomType < typeStyles.Length; geomType++)
//{
// ThemeCategory themeCat = new ThemeCategory()
// {
// MinScale = minScale,
// MaxScale = maxScale,
// GeometryType = geomType
// };
// if (layerMeta.CategoryExists(themeCat))
// continue;
// int catIndex = 0;
// XmlNodeList typeStyle = scaleRange.GetElementsByTagName(typeStyles[geomType]);
// for (int st = 0; st < typeStyle.Count; st++)
// {
// // We will check if this typestyle is going to be shown in the legend
// XmlNodeList showInLegend = ((XmlElement)typeStyle[st]).GetElementsByTagName("ShowInLegend");
// if (showInLegend.Count > 0)
// if (!bool.Parse(showInLegend[0].ChildNodes[0].Value))
// continue; // This typestyle does not need to be shown in the legend
// XmlNodeList rules = ((XmlElement)typeStyle[st]).GetElementsByTagName(ruleNames[geomType]);
// if (rules.Count > 1)
// {
// layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_theme);
// node.ToolTipText = string.Format(Properties.Resources.ThemedLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName, rules.Count);
// if (_legend.ThemeCompressionLimit > 0 && rules.Count > _legend.ThemeCompressionLimit)
// {
// AddThemeRuleNode(layerMeta, themeCat, node, geomType, 0, rules, 0);
// node.Nodes.Add(CreateCompressedThemeNode(layerMeta, themeCat, rules.Count - 2));
// AddThemeRuleNode(layerMeta, themeCat, node, geomType, rules.Count - 1, rules, rules.Count - 1);
// }
// else
// {
// for (int r = 0; r < rules.Count; r++)
// {
// AddThemeRuleNode(layerMeta, themeCat, node, geomType, catIndex++, rules, r);
// }
// }
// }
// else
// {
// if (LayerNodeMetadata.ScaleIsApplicable(_map.ViewScale, themeCat))
// {
// if (!layerMeta.HasDefaultIconsAt(_map.ViewScale))
// {
// try
// {
// var img = _map.GetLegendImage(layer.LayerDefinitionID,
// _map.ViewScale,
// 16,
// 16,
// "PNG",
// -1,
// -1);
// legendCallCount++;
// layerMeta.SetDefaultIcon(themeCat, img);
// node.ToolTipText = string.Format(Properties.Resources.DefaultLayerTooltip, Environment.NewLine, layer.Name, layer.FeatureSourceID, layer.QualifiedClassName);
// }
// catch
// {
// //layerMeta.SetDefaultIcon(themeCat, Properties.Resources.lc_broken);
// }
// }
// }
// }
// }
//}
}
}
else //Already cached
{
Trace.TraceInformation("Icons already cached for: " + layer.Name);
node.Nodes.AddRange(layerMeta.CreateThemeNodesFromCachedMetadata(_map.ViewScale));
}
}
return node;
}
private TreeNode CreateThemeRuleNode(LayerNodeMetadata layer, ThemeCategory themeCat, double viewScale, string labelText, int geomType, int categoryIndex)
{
var lyr = layer.Layer;
TreeNode node = new TreeNode();
node.Text = labelText;
Image icon = _map.GetLegendImage(lyr.LayerDefinitionID,
viewScale,
16,
16,
"PNG",
geomType,
categoryIndex);
legendCallCount++;
var tag = new LayerThemeNodeMetadata(false, icon, labelText);
layer.AddThemeNode(themeCat, tag);
node.Tag = tag;
return node;
}
private void AddThemeRuleNode(LayerNodeMetadata layerMeta, ThemeCategory themeCat, TreeNode node, int geomType, int catIndex, XmlNodeList rules, int ruleOffset)
{
XmlElement rule = (XmlElement)rules[ruleOffset];
XmlNodeList label = rule.GetElementsByTagName("LegendLabel");
XmlNodeList filter = rule.GetElementsByTagName("Filter");
String labelText = "";
if (label != null && label.Count > 0 && label[0].ChildNodes.Count > 0)
labelText = label[0].ChildNodes[0].Value;
//String filterText = "";
//if (filter != null && filter.Count > 0 && filter[0].ChildNodes.Count > 0)
// filterText = filter[0].ChildNodes[0].Value;
if (LayerNodeMetadata.ScaleIsApplicable(_map.ViewScale, themeCat))
{
var child = CreateThemeRuleNode(layerMeta, themeCat, _map.ViewScale, labelText, (geomType + 1), catIndex);
node.Nodes.Add(child);
}
else
{
}
}
public void SetDefaultIcon(ThemeCategory cat, Image image)
{
_defaultIcons[cat] = image;
}
public List<LayerThemeNodeMetadata> GetThemeNodes(ThemeCategory category)
{
if (_themeNodes.ContainsKey(category))
return _themeNodes[category];
return null;
}
public void AddThemeNode(ThemeCategory category, LayerThemeNodeMetadata themeMeta)
{
if (!_themeNodes.ContainsKey(category))
_themeNodes[category] = new List<LayerThemeNodeMetadata>();
_themeNodes[category].Add(themeMeta);
}
internal bool CategoryExists(ThemeCategory themeCat)
{
return _themeNodes.ContainsKey(themeCat);
}
