private void AddUwpModeItem()
{
XmlDocument doc = AppDic.ReadXml(AppConfig.WebUwpModeItemsDic,
AppConfig.UserUwpModeItemsDic, Properties.Resources.UwpModeItemsDic);
List <Guid> guids = new List <Guid>();
foreach (XmlElement sceneXE in doc.DocumentElement.ChildNodes)
{
if (sceneXE.Name == Scene.ToString())
{
foreach (XmlElement itemXE in sceneXE.ChildNodes)
{
if (GuidEx.TryParse(itemXE.GetAttribute("Guid"), out Guid guid))
{
if (guids.Contains(guid))
{
continue;
}
string uwpName = GuidInfo.GetUwpName(guid);
if (!string.IsNullOrEmpty(uwpName))
{
this.AddItem(new UwpModeItem(uwpName, guid));
guids.Add(guid);
}
}
}
}
}
}
public static Dictionary <string, Guid> GetPathAndGuids(string shellExPath)
{
Dictionary <string, Guid> dic = new Dictionary <string, Guid>();
foreach (string cmhPart in CmhParts)
{
using (RegistryKey cmKey = RegistryEx.GetRegistryKey($@"{shellExPath}\{cmhPart}"))
{
if (cmKey == null)
{
continue;
}
foreach (string keyName in cmKey.GetSubKeyNames())
{
using (RegistryKey key = cmKey.OpenSubKey(keyName))
{
if (!GuidEx.TryParse(key.GetValue("")?.ToString(), out Guid guid))
{
GuidEx.TryParse(keyName, out guid);
}
if (!guid.Equals(Guid.Empty))
{
dic.Add(key.Name, guid);
}
}
}
}
}
return(dic);
}
private void LoadShellExItems(XmlElement shellExXE, GroupPathItem groupItem)
{
foreach (XmlElement itemXE in shellExXE.SelectNodes("Item"))
{
if (!JudgeOSVersion(itemXE))
{
continue;
}
if (!GuidEx.TryParse(itemXE.GetAttribute("Guid"), out Guid guid))
{
continue;
}
EnhanceShellExItem item = new EnhanceShellExItem
{
FoldGroupItem = groupItem,
ShellExPath = $@"{groupItem.TargetPath}\ShellEx",
Image = ResourceIcon.GetIcon(itemXE.GetAttribute("Icon"))?.ToBitmap() ?? AppImage.DllDefaultIcon,
Text = ResourceString.GetDirectString(itemXE.GetAttribute("Text")),
DefaultKeyName = itemXE.GetAttribute("KeyName"),
Guid = guid
};
if (item.Text.IsNullOrWhiteSpace())
{
item.Text = GuidInfo.GetText(guid);
}
if (item.DefaultKeyName.IsNullOrWhiteSpace())
{
item.DefaultKeyName = guid.ToString("B");
}
item.ChkVisible.Checked = item.ItemVisible;
MyToolTip.SetToolTip(item.ChkVisible, itemXE.GetAttribute("Tip"));
this.AddItem(item);
}
}
private void LoadShellExItems(XmlNode shellExXN, FoldGroupItem groupItem)
{
foreach (XmlNode itemXN in shellExXN.SelectNodes("Item"))
{
if (!XmlDicHelper.FileExists(itemXN))
{
continue;
}
if (!XmlDicHelper.JudgeCulture(itemXN))
{
continue;
}
if (!XmlDicHelper.JudgeOSVersion(itemXN))
{
continue;
}
if (!GuidEx.TryParse(itemXN.SelectSingleNode("Guid")?.InnerText, out Guid guid))
{
continue;
}
EnhanceShellExItem item = new EnhanceShellExItem
{
FoldGroupItem = groupItem,
ShellExPath = $@"{groupItem.GroupPath}\ShellEx",
Image = ResourceIcon.GetIcon(itemXN.SelectSingleNode("Icon")?.InnerText)?.ToBitmap() ?? AppImage.SystemFile,
DefaultKeyName = itemXN.SelectSingleNode("KeyName")?.InnerText,
Guid = guid
};
foreach (XmlNode textXE in itemXN.SelectNodes("Text"))
{
if (XmlDicHelper.JudgeCulture(textXE))
{
item.Text = ResourceString.GetDirectString(textXE.InnerText);
}
}
if (item.Text.IsNullOrWhiteSpace())
{
item.Text = GuidInfo.GetText(guid);
}
if (item.DefaultKeyName.IsNullOrWhiteSpace())
{
item.DefaultKeyName = guid.ToString("B");
}
string tip = "";
foreach (XmlElement tipXE in itemXN.SelectNodes("Tip"))
{
if (XmlDicHelper.JudgeCulture(tipXE))
{
tip = tipXE.GetAttribute("Text");
}
}
ToolTipBox.SetToolTip(item.ChkVisible, tip);
this.AddItem(item);
}
}
private void AddNewItem()
{
MyListItem newItem = new MyListItem
{
Text = AppString.Item.AddGuidBlockedItem,
Image = AppImage.AddNewItem
};
PictureButton btnAddNewItem = new PictureButton(AppImage.AddNewItem);
newItem.AddCtr(btnAddNewItem);
newItem.SetNoClickEvent();
this.AddItem(newItem);
MyToolTip.SetToolTip(btnAddNewItem, newItem.Text);
btnAddNewItem.MouseDown += (sender, e) =>
{
using (InputDialog dlg = new InputDialog {
Title = AppString.Dialog.InputGuid
})
{
if (GuidEx.TryParse(Clipboard.GetText(), out Guid guid))
{
dlg.Text = guid.ToString();
}
if (dlg.ShowDialog() != DialogResult.OK)
{
return;
}
if (GuidEx.TryParse(dlg.Text, out guid))
{
Array.ForEach(GuidBlockedItem.BlockedPaths, path =>
{
Registry.SetValue(path, guid.ToString("B"), string.Empty);
});
for (int i = 1; i < Controls.Count; i++)
{
if (((GuidBlockedItem)Controls[i]).Guid.Equals(guid))
{
MessageBoxEx.Show(AppString.MessageBox.HasBeenAdded);
return;
}
}
this.InsertItem(new GuidBlockedItem(dlg.Text), 1);
ExplorerRestarter.NeedRestart = true;
}
else
{
MessageBoxEx.Show(AppString.MessageBox.MalformedGuid);
}
}
};
}
public GuidBlockedItem(string value)
{
InitializeComponents();
this.Value = value;
if (GuidEx.TryParse(value, out Guid guid))
{
this.Guid = guid;
this.Image = GuidInfo.GetImage(guid);
this.ItemFilePath = GuidInfo.GetFilePath(Guid);
}
else
{
this.Guid = Guid.Empty;
this.Image = AppImage.SystemFile;
}
this.Text = this.ItemText;
}
private void AddNewItem()
{
NewItem newItem = new NewItem(AppString.Item.AddGuidBlockedItem);
this.AddItem(newItem);
newItem.AddNewItem += (sender, e) =>
{
using (InputDialog dlg = new InputDialog {
Title = AppString.Dialog.InputGuid
})
{
if (GuidEx.TryParse(Clipboard.GetText(), out Guid guid))
{
dlg.Text = guid.ToString();
}
if (dlg.ShowDialog() != DialogResult.OK)
{
return;
}
if (GuidEx.TryParse(dlg.Text, out guid))
{
Array.ForEach(GuidBlockedItem.BlockedPaths, path =>
{
Registry.SetValue(path, guid.ToString("B"), string.Empty);
});
for (int i = 1; i < Controls.Count; i++)
{
if (((GuidBlockedItem)Controls[i]).Guid.Equals(guid))
{
MessageBoxEx.Show(AppString.MessageBox.HasBeenAdded);
return;
}
}
this.InsertItem(new GuidBlockedItem(dlg.Text), 1);
ExplorerRestarter.Show();
}
else
{
MessageBoxEx.Show(AppString.MessageBox.MalformedGuid);
}
}
};
}
public GuidBlockedItem(string value)
{
InitializeComponents();
this.Value = value;
if (GuidEx.TryParse(value, out Guid guid))
{
this.Guid = guid;
this.Text = GuidInfo.GetText(guid);
this.Image = GuidInfo.GetImage(guid);
this.ItemFilePath = GuidInfo.GetFilePath(Guid);
}
else
{
this.Guid = Guid.Empty;
this.Text = AppString.MessageBox.MalformedGuid;
this.Image = AppImage.DllDefaultIcon;
}
this.Text += "\n" + value;
}
public static bool TryGetGuid(string value, out Guid guid, out string guidPath)
{
guidPath = null;
if (!GuidEx.TryParse(value, out guid))
{
return(false);
}
foreach (string path in ClsidPaths)
{
using (RegistryKey key = RegistryEx.GetRegistryKey($@"{path}\{guid:B}"))
{
if (key != null)
{
guidPath = key.Name;
return(true);
}
}
}
return(false);
}
private void AddNewShellExItem(string scenePath)
{
bool isDragDrop = Scene == Scenes.DragDrop;
using (InputDialog dlg1 = new InputDialog {
Title = AppString.Dialog.InputGuid
})
{
if (GuidEx.TryParse(Clipboard.GetText(), out Guid guid))
{
dlg1.Text = guid.ToString();
}
if (dlg1.ShowDialog() != DialogResult.OK)
{
return;
}
if (GuidEx.TryParse(dlg1.Text, out guid))
{
if (isDragDrop)
{
using (SelectDialog dlg2 = new SelectDialog())
{
dlg2.Title = AppString.Dialog.SelectGroup;
dlg2.Items = new[] { AppString.SideBar.Folder, AppString.SideBar.Directory,
AppString.SideBar.Drive, AppString.SideBar.AllObjects };
dlg2.Selected = dlg2.Items[0];
if (dlg2.ShowDialog() != DialogResult.OK)
{
return;
}
switch (dlg2.SelectedIndex)
{
case 0:
scenePath = MENUPATH_FOLDER; break;
case 1:
scenePath = MENUPATH_DIRECTORY; break;
case 2:
scenePath = MENUPATH_DRIVE; break;
case 3:
scenePath = MENUPATH_ALLOBJECTS; break;
}
}
}
string shellExPath = GetShellExPath(scenePath);
if (ShellExItem.GetPathAndGuids(shellExPath, isDragDrop).Values.Contains(guid))
{
MessageBoxEx.Show(AppString.MessageBox.HasBeenAdded);
}
else
{
string part = isDragDrop ? ShellExItem.DdhParts[0] : ShellExItem.CmhParts[0];
string regPath = $@"{shellExPath}\{part}\{guid:B}";
Registry.SetValue(regPath, "", guid.ToString("B"));
ShellExItem item = new ShellExItem(guid, regPath);
for (int i = 0; i < this.Controls.Count; i++)
{
if (isDragDrop)
{
if (this.Controls[i] is GroupPathItem groupItem)
{
if (groupItem.TargetPath.Equals(shellExPath, StringComparison.OrdinalIgnoreCase))
{
this.InsertItem(item, i + 1);
item.FoldGroupItem = groupItem;
item.Visible = !groupItem.IsFold;
break;
}
}
}
else
{
if (this.Controls[i] is NewItem)
{
this.InsertItem(item, i + 1);
break;
}
}
}
}
}
else
{
MessageBoxEx.Show(AppString.MessageBox.MalformedGuid);
}
}
}
public void LoadItems()
{
try
{
XmlDocument doc = AppDic.ReadXml(AppConfig.WebThirdRulesDic,
AppConfig.UserThirdRulesDic, Properties.Resources.ThirdRulesDic);
foreach (XmlElement groupXE in doc.DocumentElement.ChildNodes)
{
Guid guid = Guid.Empty;
if (groupXE.HasAttribute("Guid"))
{
if (GuidEx.TryParse(groupXE.GetAttribute("Guid"), out guid))
{
if (!File.Exists(GuidInfo.GetFilePath(guid)))
{
continue;
}
}
else
{
continue;
}
}
GroupPathItem groupItem;
bool isIniGroup = groupXE.HasAttribute("IsIniGroup");
string attribute = isIniGroup ? "FilePath" : "RegPath";
ObjectPath.PathType pathType = isIniGroup ? ObjectPath.PathType.File : ObjectPath.PathType.Registry;
groupItem = new GroupPathItem(groupXE.GetAttribute(attribute), pathType)
{
Text = groupXE.GetAttribute("Text"),
Image = GuidInfo.GetImage(guid)
};
if (groupItem.Text.IsNullOrWhiteSpace())
{
groupItem.Text = GuidInfo.GetText(guid);
}
this.AddItem(groupItem);
string GetRuleFullRegPath(string regPath)
{
if (string.IsNullOrEmpty(regPath))
{
regPath = groupItem.TargetPath;
}
else if (regPath.StartsWith("\\"))
{
regPath = groupItem.TargetPath + regPath;
}
return(regPath);
};
foreach (XmlElement itemXE in groupXE.ChildNodes)
{
if (!EnhanceMenusList.JudgeOSVersion(itemXE))
{
continue;
}
RuleItem ruleItem;
ItemInfo info = new ItemInfo
{
Text = itemXE.GetAttribute("Text"),
Tip = itemXE.GetAttribute("Tip"),
RestartExplorer = itemXE.HasAttribute("RestartExplorer"),
};
int defaultValue = 0, maxValue = 0, minValue = 0;
if (itemXE.HasAttribute("IsNumberItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
defaultValue = ruleXE.HasAttribute("Default") ? Convert.ToInt32(ruleXE.GetAttribute("Default")) : 0;
maxValue = ruleXE.HasAttribute("Max") ? Convert.ToInt32(ruleXE.GetAttribute("Max")) : int.MaxValue;
minValue = ruleXE.HasAttribute("Min") ? Convert.ToInt32(ruleXE.GetAttribute("Min")) : int.MinValue;
}
if (isIniGroup)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
string iniPath = ruleXE.GetAttribute("FilePath");
if (iniPath.IsNullOrWhiteSpace())
{
iniPath = groupItem.TargetPath;
}
string section = ruleXE.GetAttribute("Section");
string keyName = ruleXE.GetAttribute("KeyName");
if (itemXE.HasAttribute("IsNumberItem"))
{
var rule = new NumberIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = maxValue
};
ruleItem = new NumberIniRuleItem(rule, info);
}
else if (itemXE.HasAttribute("IsStringItem"))
{
var rule = new StringIniRuleItem.IniRule
{
IniPath = iniPath,
Secation = section,
KeyName = keyName
};
ruleItem = new StringIniRuleItem(rule, info);
}
else
{
var rule = new VisbleIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
TurnOnValue = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null,
TurnOffValue = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null,
};
ruleItem = new VisbleIniRuleItem(rule, info);
}
}
else
{
if (itemXE.HasAttribute("IsNumberItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new NumberRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = GetValueKind(ruleXE.GetAttribute("ValueKind")),
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = minValue
};
ruleItem = new NumberRegRuleItem(rule, info);
}
else if (itemXE.HasAttribute("IsStringItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new StringRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
};
ruleItem = new StringRegRuleItem(rule, info);
}
else
{
XmlNodeList ruleXNList = itemXE.SelectNodes("Rule");
var rules = new VisibleRegRuleItem.RegRule[ruleXNList.Count];
for (int i = 0; i < ruleXNList.Count; i++)
{
XmlElement ruleXE = (XmlElement)ruleXNList[i];
rules[i] = new VisibleRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = GetValueKind(ruleXE.GetAttribute("ValueKind")),
TurnOnValue = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null,
TurnOffValue = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null,
};
}
ruleItem = new VisibleRegRuleItem(rules, info);
}
}
this.AddItem(ruleItem);
ruleItem.HasImage = false;
ruleItem.FoldGroupItem = groupItem;
}
groupItem.IsFold = true;
groupItem.HideWhenNoSubItem();
}
}
catch { }
}
/// <summary>重新加载字典</summary>
public static void ReloadDics()
{
XmlDocument LoadXml(string xmlPath)
{
if (!File.Exists(xmlPath))
{
return(null);
}
try
{
XmlDocument doc = new XmlDocument();
Encoding encoding = EncodingType.GetType(xmlPath);
string xml = File.ReadAllText(xmlPath, encoding).Trim();
doc.LoadXml(xml);
return(doc);
}
catch (Exception e)
{
AppMessageBox.Show(e.Message + "\n" + xmlPath);
return(null);
}
}
void LoadDic(List <XmlDocument> dic, string webPath, string userPath, string defaultContent)
{
if (!File.Exists(webPath))
{
File.WriteAllText(webPath, defaultContent, Encoding.Unicode);
}
dic.Clear();
dic.Add(LoadXml(webPath));
dic.Add(LoadXml(userPath));
}
LoadDic(UwpModeItemsDic, AppConfig.WebUwpModeItemsDic,
AppConfig.UserUwpModeItemsDic, Properties.Resources.UwpModeItemsDic);
LoadDic(EnhanceMenusDic, AppConfig.WebEnhanceMenusDic,
AppConfig.UserEnhanceMenusDic, Properties.Resources.EnhanceMenusDic);
LoadDic(DetailedEditDic, AppConfig.WebDetailedEditDic,
AppConfig.UserDetailedEditDic, Properties.Resources.DetailedEditDic);
EnhanceMenuPathDic.Clear();
for (int i = 0; i < 2; i++)
{
XmlDocument doc = EnhanceMenusDic[i];
if (doc?.DocumentElement == null)
{
continue;
}
foreach (XmlNode pathXN in doc.SelectNodes("Data/Group/RegPath"))
{
if (EnhanceMenuPathDic.ContainsKey(pathXN.InnerText))
{
continue;
}
EnhanceMenuPathDic.Add(pathXN.InnerText, i == 1);
}
}
DetailedEditGuidDic.Clear();
for (int i = 0; i < 2; i++)
{
XmlDocument doc = DetailedEditDic[i];
if (doc?.DocumentElement == null)
{
continue;
}
foreach (XmlNode guidXN in doc.SelectNodes("Data/Group/Guid"))
{
if (GuidEx.TryParse(guidXN.InnerText, out Guid guid))
{
if (DetailedEditGuidDic.ContainsKey(guid))
{
continue;
}
DetailedEditGuidDic.Add(guid, i == 1);
}
}
}
}
public override void LoadItems()
{
base.LoadItems();
int index = this.UseUserDic ? 1 : 0;
XmlDocument doc = XmlDicHelper.DetailedEditDic[index];
if (doc?.DocumentElement == null)
{
return;
}
foreach (XmlNode groupXN in doc.DocumentElement.ChildNodes)
{
try
{
List <Guid> guids = new List <Guid>();
XmlNodeList guidList = groupXN.SelectNodes("Guid");
foreach (XmlNode guidXN in guidList)
{
if (!GuidEx.TryParse(guidXN.InnerText, out Guid guid))
{
continue;
}
if (!File.Exists(GuidInfo.GetFilePath(guid)))
{
continue;
}
if (this.GroupGuid != Guid.Empty && this.GroupGuid != guid)
{
continue;
}
guids.Add(guid);
}
if (guidList.Count > 0 && guids.Count == 0)
{
continue;
}
FoldGroupItem groupItem;
bool isIniGroup = groupXN.SelectSingleNode("IsIniGroup") != null;
string attribute = isIniGroup ? "FilePath" : "RegPath";
ObjectPath.PathType pathType = isIniGroup ? ObjectPath.PathType.File : ObjectPath.PathType.Registry;
groupItem = new FoldGroupItem(groupXN.SelectSingleNode(attribute)?.InnerText, pathType);
foreach (XmlElement textXE in groupXN.SelectNodes("Text"))
{
if (XmlDicHelper.JudgeCulture(textXE))
{
groupItem.Text = ResourceString.GetDirectString(textXE.GetAttribute("Value"));
}
}
if (guids.Count > 0)
{
groupItem.Tag = guids;
if (groupItem.Text.IsNullOrWhiteSpace())
{
groupItem.Text = GuidInfo.GetText(guids[0]);
}
groupItem.Image = GuidInfo.GetImage(guids[0]);
string filePath = GuidInfo.GetFilePath(guids[0]);
string clsidPath = GuidInfo.GetClsidPath(guids[0]);
if (filePath != null || clsidPath != null)
{
groupItem.ContextMenuStrip.Items.Add(new ToolStripSeparator());
}
if (filePath != null)
{
ToolStripMenuItem tsi = new ToolStripMenuItem(AppString.Menu.FileLocation);
tsi.Click += (sender, e) => ExternalProgram.JumpExplorer(filePath, AppConfig.OpenMoreExplorer);
groupItem.ContextMenuStrip.Items.Add(tsi);
}
if (clsidPath != null)
{
ToolStripMenuItem tsi = new ToolStripMenuItem(AppString.Menu.ClsidLocation);
tsi.Click += (sender, e) => ExternalProgram.JumpRegEdit(clsidPath, null, AppConfig.OpenMoreRegedit);
groupItem.ContextMenuStrip.Items.Add(tsi);
}
}
XmlNode iconXN = groupXN.SelectSingleNode("Icon");
using (Icon icon = ResourceIcon.GetIcon(iconXN?.InnerText))
{
if (icon != null)
{
groupItem.Image = icon.ToBitmap();
}
}
this.AddItem(groupItem);
string GetRuleFullRegPath(string regPath)
{
if (string.IsNullOrEmpty(regPath))
{
regPath = groupItem.GroupPath;
}
else if (regPath.StartsWith("\\"))
{
regPath = groupItem.GroupPath + regPath;
}
return(regPath);
};
foreach (XmlElement itemXE in groupXN.SelectNodes("Item"))
{
try
{
if (!XmlDicHelper.JudgeOSVersion(itemXE))
{
continue;
}
RuleItem ruleItem;
ItemInfo info = new ItemInfo();
foreach (XmlElement textXE in itemXE.SelectNodes("Text"))
{
if (XmlDicHelper.JudgeCulture(textXE))
{
info.Text = ResourceString.GetDirectString(textXE.GetAttribute("Value"));
}
}
foreach (XmlElement tipXE in itemXE.SelectNodes("Tip"))
{
if (XmlDicHelper.JudgeCulture(tipXE))
{
info.Tip = ResourceString.GetDirectString(tipXE.GetAttribute("Value"));
}
}
info.RestartExplorer = itemXE.SelectSingleNode("RestartExplorer") != null;
int defaultValue = 0, maxValue = 0, minValue = 0;
if (itemXE.SelectSingleNode("IsNumberItem") != null)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
defaultValue = ruleXE.HasAttribute("Default") ? Convert.ToInt32(ruleXE.GetAttribute("Default")) : 0;
maxValue = ruleXE.HasAttribute("Max") ? Convert.ToInt32(ruleXE.GetAttribute("Max")) : int.MaxValue;
minValue = ruleXE.HasAttribute("Min") ? Convert.ToInt32(ruleXE.GetAttribute("Min")) : int.MinValue;
}
if (isIniGroup)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
string iniPath = ruleXE.GetAttribute("FilePath");
if (iniPath.IsNullOrWhiteSpace())
{
iniPath = groupItem.GroupPath;
}
string section = ruleXE.GetAttribute("Section");
string keyName = ruleXE.GetAttribute("KeyName");
if (itemXE.SelectSingleNode("IsNumberItem") != null)
{
var rule = new NumberIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = maxValue
};
ruleItem = new NumberIniRuleItem(rule, info);
}
else if (itemXE.SelectSingleNode("IsStringItem") != null)
{
var rule = new StringIniRuleItem.IniRule
{
IniPath = iniPath,
Secation = section,
KeyName = keyName
};
ruleItem = new StringIniRuleItem(rule, info);
}
else
{
var rule = new VisbleIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
TurnOnValue = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null,
TurnOffValue = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null,
};
ruleItem = new VisbleIniRuleItem(rule, info);
}
}
else
{
if (itemXE.SelectSingleNode("IsNumberItem") != null)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new NumberRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = XmlDicHelper.GetValueKind(ruleXE.GetAttribute("ValueKind"), RegistryValueKind.DWord),
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = minValue
};
ruleItem = new NumberRegRuleItem(rule, info);
}
else if (itemXE.SelectSingleNode("IsStringItem") != null)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new StringRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
};
ruleItem = new StringRegRuleItem(rule, info);
}
else
{
XmlNodeList ruleXNList = itemXE.SelectNodes("Rule");
var rules = new VisibleRegRuleItem.RegRule[ruleXNList.Count];
for (int i = 0; i < ruleXNList.Count; i++)
{
XmlElement ruleXE = (XmlElement)ruleXNList[i];
rules[i] = new VisibleRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = XmlDicHelper.GetValueKind(ruleXE.GetAttribute("ValueKind"), RegistryValueKind.DWord)
};
string turnOn = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null;
string turnOff = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null;
switch (rules[i].ValueKind)
{
case RegistryValueKind.Binary:
rules[i].TurnOnValue = turnOn != null?XmlDicHelper.ConvertToBinary(turnOn) : null;
rules[i].TurnOffValue = turnOff != null?XmlDicHelper.ConvertToBinary(turnOff) : null;
break;
case RegistryValueKind.DWord:
if (turnOn == null)
{
rules[i].TurnOnValue = null;
}
else
{
rules[i].TurnOnValue = Convert.ToInt32(turnOn);
}
if (turnOff == null)
{
rules[i].TurnOffValue = null;
}
else
{
rules[i].TurnOffValue = Convert.ToInt32(turnOff);
}
break;
default:
rules[i].TurnOnValue = turnOn;
rules[i].TurnOffValue = turnOff;
break;
}
}
ruleItem = new VisibleRegRuleItem(rules, info);
}
}
this.AddItem(ruleItem);
ruleItem.FoldGroupItem = groupItem;
ruleItem.HasImage = ruleItem.Image != null;
ruleItem.Indent();
}
catch { continue; }
}
groupItem.SetVisibleWithSubItemCount();
}
catch { continue; }
}
}
public void LoadItems()
{
try
{
foreach (XmlElement groupXE in ReadXml().DocumentElement.ChildNodes)
{
Guid guid = Guid.Empty;
if (groupXE.HasAttribute("Guid"))
{
if (GuidEx.TryParse(groupXE.GetAttribute("Guid"), out guid))
{
if (!File.Exists(GuidInfo.GetFilePath(guid)))
{
continue;
}
}
else
{
continue;
}
}
GroupPathItem groupItem = new GroupPathItem(groupXE.GetAttribute("RegPath"), ObjectPath.PathType.Registry)
{
Text = groupXE.GetAttribute("Text"),
Image = GuidInfo.GetImage(guid),
};
if (groupItem.Text.IsNullOrWhiteSpace())
{
groupItem.Text = GuidInfo.GetText(guid);
}
this.AddItem(groupItem);
foreach (XmlElement itemXE in groupXE.ChildNodes)
{
if (!EnhanceMenusList.JudgeOSVersion(itemXE))
{
continue;
}
RegRuleItem.ItemInfo itemInfo = new RegRuleItem.ItemInfo
{
Text = itemXE.GetAttribute("Text"),
Tip = itemXE.GetAttribute("Tip"),
RestartExplorer = itemXE.HasAttribute("RestartExplorer"),
};
XmlNodeList ruleXNList = itemXE.GetElementsByTagName("Rule");//Rules
RegRuleItem.RegRule[] rules = new RegRuleItem.RegRule[ruleXNList.Count];
for (int i = 0; i < ruleXNList.Count; i++)
{
XmlElement ruleXE = (XmlElement)ruleXNList[i];
rules[i] = new RegRuleItem.RegRule
{
RegPath = ruleXE.GetAttribute("RegPath"),
ValueName = ruleXE.GetAttribute("ValueName"),
TurnOnValue = ruleXE.GetAttribute("On"),
TurnOffValue = ruleXE.GetAttribute("Off"),
ValueKind = GetValueKind(ruleXE.GetAttribute("ValueKind"))
};
if (string.IsNullOrEmpty(rules[i].RegPath))
{
rules[i].RegPath = groupItem.TargetPath;
}
else if (rules[i].RegPath.StartsWith("\\"))
{
rules[i].RegPath = groupItem.TargetPath + rules[i].RegPath;
}
}
this.AddItem(new RegRuleItem(rules, itemInfo)
{
FoldGroupItem = groupItem, HasImage = false
});
}
groupItem.IsFold = true;
groupItem.HideWhenNoSubItem();
}
}
catch { }
}
private void LoadDocItems(string xmlPath, GroupPathItem groupItem)
{
if (!File.Exists(xmlPath))
{
return;
}
this.AddItem(groupItem);
XmlDocument doc = new XmlDocument();
try { doc.LoadXml(File.ReadAllText(xmlPath, EncodingType.GetType(xmlPath)).Trim()); }
catch (Exception e) { MessageBoxEx.Show(e.Message); return; }
foreach (XmlElement groupXE in doc.DocumentElement.ChildNodes)
{
try
{
Guid guid = Guid.Empty;
if (groupXE.HasAttribute("Guid"))
{
if (GuidEx.TryParse(groupXE.GetAttribute("Guid"), out guid))
{
if (!File.Exists(GuidInfo.GetFilePath(guid)))
{
continue;
}
}
else
{
continue;
}
}
SubGroupItem subGroupItem;
bool isIniGroup = groupXE.HasAttribute("IsIniGroup");
string attribute = isIniGroup ? "FilePath" : "RegPath";
ObjectPath.PathType pathType = isIniGroup ? ObjectPath.PathType.File : ObjectPath.PathType.Registry;
subGroupItem = new SubGroupItem(groupXE.GetAttribute(attribute), pathType)
{
Text = groupXE.GetAttribute("Text"),
Image = GuidInfo.GetImage(guid)
};
if (subGroupItem.Text.IsNullOrWhiteSpace())
{
subGroupItem.Text = GuidInfo.GetText(guid);
}
this.AddItem(subGroupItem);
string GetRuleFullRegPath(string regPath)
{
if (string.IsNullOrEmpty(regPath))
{
regPath = subGroupItem.TargetPath;
}
else if (regPath.StartsWith("\\"))
{
regPath = subGroupItem.TargetPath + regPath;
}
return(regPath);
};
foreach (XmlElement itemXE in groupXE.ChildNodes)
{
try
{
if (!EnhanceMenusList.JudgeOSVersion(itemXE))
{
continue;
}
RuleItem ruleItem;
ItemInfo info = new ItemInfo
{
Text = itemXE.GetAttribute("Text"),
Tip = itemXE.GetAttribute("Tip"),
RestartExplorer = itemXE.HasAttribute("RestartExplorer"),
};
int defaultValue = 0, maxValue = 0, minValue = 0;
if (itemXE.HasAttribute("IsNumberItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
defaultValue = ruleXE.HasAttribute("Default") ? Convert.ToInt32(ruleXE.GetAttribute("Default")) : 0;
maxValue = ruleXE.HasAttribute("Max") ? Convert.ToInt32(ruleXE.GetAttribute("Max")) : int.MaxValue;
minValue = ruleXE.HasAttribute("Min") ? Convert.ToInt32(ruleXE.GetAttribute("Min")) : int.MinValue;
}
if (isIniGroup)
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
string iniPath = ruleXE.GetAttribute("FilePath");
if (iniPath.IsNullOrWhiteSpace())
{
iniPath = subGroupItem.TargetPath;
}
string section = ruleXE.GetAttribute("Section");
string keyName = ruleXE.GetAttribute("KeyName");
if (itemXE.HasAttribute("IsNumberItem"))
{
var rule = new NumberIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = maxValue
};
ruleItem = new NumberIniRuleItem(rule, info);
}
else if (itemXE.HasAttribute("IsStringItem"))
{
var rule = new StringIniRuleItem.IniRule
{
IniPath = iniPath,
Secation = section,
KeyName = keyName
};
ruleItem = new StringIniRuleItem(rule, info);
}
else
{
var rule = new VisbleIniRuleItem.IniRule
{
IniPath = iniPath,
Section = section,
KeyName = keyName,
TurnOnValue = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null,
TurnOffValue = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null,
};
ruleItem = new VisbleIniRuleItem(rule, info);
}
}
else
{
if (itemXE.HasAttribute("IsNumberItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new NumberRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = GetValueKind(ruleXE.GetAttribute("ValueKind")),
DefaultValue = defaultValue,
MaxValue = maxValue,
MinValue = minValue
};
ruleItem = new NumberRegRuleItem(rule, info);
}
else if (itemXE.HasAttribute("IsStringItem"))
{
XmlElement ruleXE = (XmlElement)itemXE.SelectSingleNode("Rule");
var rule = new StringRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
};
ruleItem = new StringRegRuleItem(rule, info);
}
else
{
XmlNodeList ruleXNList = itemXE.SelectNodes("Rule");
var rules = new VisibleRegRuleItem.RegRule[ruleXNList.Count];
for (int i = 0; i < ruleXNList.Count; i++)
{
XmlElement ruleXE = (XmlElement)ruleXNList[i];
rules[i] = new VisibleRegRuleItem.RegRule
{
RegPath = GetRuleFullRegPath(ruleXE.GetAttribute("RegPath")),
ValueName = ruleXE.GetAttribute("ValueName"),
ValueKind = GetValueKind(ruleXE.GetAttribute("ValueKind"))
};
string turnOn = ruleXE.HasAttribute("On") ? ruleXE.GetAttribute("On") : null;
string turnOff = ruleXE.HasAttribute("Off") ? ruleXE.GetAttribute("Off") : null;
switch (rules[i].ValueKind)
{
case RegistryValueKind.Binary:
rules[i].TurnOnValue = turnOn != null?EnhanceMenusList.ConvertToBinary(turnOn) : null;
rules[i].TurnOffValue = turnOff != null?EnhanceMenusList.ConvertToBinary(turnOff) : null;
break;
case RegistryValueKind.DWord:
if (turnOn == null)
{
rules[i].TurnOnValue = null;
}
else
{
rules[i].TurnOnValue = Convert.ToInt32(turnOn);
}
if (turnOff == null)
{
rules[i].TurnOffValue = null;
}
else
{
rules[i].TurnOffValue = Convert.ToInt32(turnOff);
}
break;
default:
rules[i].TurnOnValue = turnOn;
rules[i].TurnOffValue = turnOff;
break;
}
}
ruleItem = new VisibleRegRuleItem(rules, info);
}
}
this.AddItem(ruleItem);
ruleItem.FoldGroupItem = subGroupItem;
}
catch { continue; }
}
subGroupItem.HideWhenNoSubItem();
subGroupItem.FoldGroupItem = groupItem;
}
catch { continue; }
}
groupItem.IsFold = true;
groupItem.HideWhenNoSubItem();
}
