public bool Remove(Preset preset)
{
if (preset == null || preset.IsDefault)
{
return(false);
}
PresetDisplayCategory cateogry = this.presets.FirstOrDefault(p => p.Category == preset.Category) as PresetDisplayCategory;
if (cateogry != null)
{
// Remove the preset, and cleanup the category if it's not got any presets in it.
cateogry.Presets.Remove(preset);
this.flatPresetList.Remove(preset);
this.flatPresetDict.Remove(preset.Name);
if (cateogry.Presets.Count == 0)
{
this.presets.Remove(cateogry);
}
}
else
{
this.presets.Remove(preset);
this.flatPresetList.Remove(preset);
this.flatPresetDict.Remove(preset.Name);
}
this.SavePresetFiles();
this.OnPresetCollectionChanged();
return(true);
}
private void GeneratePresets(List <object> groupedMenu, IList <IPresetObject> userPresets, PresetDisplayMode displayMode)
{
if (!userPresets.Any(s => s.Category != PresetService.UserPresetCategoryName))
{
return;
}
if (displayMode == PresetDisplayMode.Partial)
{
groupedMenu.Add(GenerateMenuHeader(Resources.Main_Presets));
groupedMenu.Add(new Separator());
}
foreach (IPresetObject presetCategory in userPresets)
{
if (displayMode == PresetDisplayMode.Partial && PresetService.UserPresetCategoryName.Equals(presetCategory.Category))
{
continue; // In Partially Flat mode, we show the user presets flat so no need to include the category.
}
PresetDisplayCategory category = presetCategory as PresetDisplayCategory;
if (category != null)
{
groupedMenu.Add(GeneratePresetGroup(category));
}
}
}
private void ProcessCategory(Dictionary <string, object> groupedMenu, PresetDisplayCategory category)
{
foreach (Preset preset in category.Presets)
{
this.ProcessPreset(groupedMenu, preset);
}
}
public void AddCategory(string categoryName)
{
if (string.IsNullOrEmpty(categoryName))
{
this.errorService.ShowMessageBox(
Resources.PresetService_CategoryNameEmpty,
Resources.Error,
MessageBoxButton.OK,
MessageBoxImage.Error);
}
PresetDisplayCategory category = this.presets.FirstOrDefault(a => a.Category == categoryName) as PresetDisplayCategory;
if (category != null)
{
this.errorService.ShowMessageBox(
Resources.PresetService_CategoryAlreadyExists,
Resources.Error,
MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
// Otherwise, if we have category but it doesn't exist, create it.
this.presets.Add(new PresetDisplayCategory(categoryName, false, new BindingList <Preset>()));
// Update the presets file
this.SavePresetFiles();
}
private void ProcessCategory(Dictionary <string, MenuItem> groupedMenu, PresetDisplayCategory category)
{
foreach (Preset preset in category.Presets.OrderBy(p => p.Name))
{
this.ProcessPreset(groupedMenu, preset);
}
}
/// <summary>Converts a value. </summary>
/// <returns>A converted value. If the method returns null, the valid null value is used.</returns>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
IEnumerable <IPresetObject> presets = value as IEnumerable <IPresetObject>;
if (presets == null)
{
return(null);
}
Dictionary <string, MenuItem> groupedMenu = new Dictionary <string, MenuItem>();
foreach (IPresetObject item in presets)
{
PresetDisplayCategory category = item as PresetDisplayCategory;
if (category != null)
{
ProcessCategory(groupedMenu, category);
continue;
}
Preset preset = item as Preset;
if (preset != null)
{
ProcessPreset(groupedMenu, preset);
}
}
return(groupedMenu.Values.ToList());
}
public void RemoveGroup(string categoryName)
{
PresetDisplayCategory category = this.presets.FirstOrDefault(p => p.Category == categoryName) as PresetDisplayCategory;
if (category != null)
{
foreach (Preset preset in category.Presets)
{
if (preset.IsDefault)
{
// Skip default preset
continue;
}
this.presets.Remove(preset);
this.flatPresetList.Remove(preset);
this.flatPresetDict.Remove(preset.Name);
}
// Cleanup the category if we can.
if (category.Presets.Count == 0)
{
this.presets.Remove(category);
}
this.SavePresetFiles();
}
}
/// <summary>
/// Add a new preset to the system.
/// Performs an Update if it already exists
/// </summary>
/// <param name="preset">
/// A Preset to add
/// </param>
/// <param name="isLoading">
/// Prevents Saving of presets.
/// </param>
/// <returns>
/// True if added,
/// False if name already exists
/// </returns>
public bool Add(Preset preset, bool isLoading)
{
if (!this.CheckIfPresetExists(preset.Name))
{
// Check to see if the category already exists.
PresetDisplayCategory category = this.presets.FirstOrDefault(a => a.Category == preset.Category) as PresetDisplayCategory; // TODO build Dict for this.
if (category != null)
{
category.Presets.Add(preset);
}
else if (!string.IsNullOrEmpty(preset.Category))
{
// Otherwise, if we have category but it doesn't exist, create it.
this.presets.Add(new PresetDisplayCategory(preset.Category, preset.IsBuildIn, new BindingList <Preset> {
preset
}));
}
else
{
// Preset has no category.
this.presets.Add(preset);
}
this.flatPresetList.Add(preset.Name, preset);
// Update the presets file
if (!isLoading)
{
this.SavePresetFiles();
}
return(true);
}
return(false);
}
public void ClearBuiltIn()
{
List <IPresetObject> topLevel = new List <IPresetObject>();
foreach (IPresetObject item in this.presets)
{
// We either have a Preset
Preset foundPreset = item as Preset;
if (foundPreset != null && foundPreset.IsBuildIn)
{
topLevel.Add(item);
}
// Or a Category.
PresetDisplayCategory foundCategory = item as PresetDisplayCategory;
if (foundCategory != null)
{
// Find all the presets in this category to remove
List <Preset> presetsToRemove = new List <Preset>();
foreach (Preset categoryPreset in foundCategory.Presets)
{
if (categoryPreset.IsBuildIn)
{
presetsToRemove.Add(categoryPreset);
}
}
// Then remove them.
foreach (Preset toRemove in presetsToRemove)
{
foundCategory.Presets.Remove(toRemove);
this.flatPresetList.Remove(toRemove);
this.flatPresetDict.Remove(toRemove.Name);
}
// Check if we can remove this category.
if (foundCategory.Presets.Count == 0)
{
topLevel.Add(foundCategory);
}
}
}
// Remove any top level items we need to remove.
foreach (var item in topLevel)
{
this.presets.Remove(item);
if (item.GetType() == typeof(Preset))
{
this.flatPresetList.Remove(((Preset)item));
this.flatPresetDict.Remove(((Preset)item).Name);
}
}
}
private void GeneratePresets(List <object> groupedMenu, IList <IPresetObject> userPresets)
{
foreach (IPresetObject presetCategory in userPresets)
{
PresetDisplayCategory category = presetCategory as PresetDisplayCategory;
if (category != null)
{
groupedMenu.Add(GeneratePresetGroup(category));
}
}
}
private MenuItem GeneratePresetGroup(PresetDisplayCategory category)
{
MenuItem group = new MenuItem();
group.Header = category.Category;
foreach (var preset in category.Presets)
{
group.Items.Add(GeneratePresetMenuItem(preset));
}
return(group);
}
public void SaveCategoryStates()
{
StringCollection expandedPresets = new StringCollection();
foreach (IPresetObject presetObject in this.presets)
{
PresetDisplayCategory category = presetObject as PresetDisplayCategory;
if (category != null && category.IsExpanded)
{
expandedPresets.Add(category.Category);
}
}
this.userSettingService.SetUserSetting(UserSettingConstants.PresetExpandedStateList, expandedPresets);
}
public static HBPresetCategory CreatePresetCategory(PresetDisplayCategory category, HBConfiguration config)
{
HBPresetCategory preset = new HBPresetCategory();
preset.Folder = true;
preset.PresetName = category.Category;
preset.PresetDescription = string.Empty;
preset.ChildrenArray = new List <HBPreset>();
foreach (Preset singlePreset in category.Presets)
{
preset.ChildrenArray.Add(CreateHbPreset(singlePreset, config));
}
return(preset);
}
private void GenerateTopUserPresets(List <object> groupedMenu, IPresetObject userPresets)
{
PresetDisplayCategory category = userPresets as PresetDisplayCategory;
if (category != null)
{
foreach (var preset in category.Presets.TakeLast(8).Reverse())
{
groupedMenu.Add(GeneratePresetMenuItem(preset));
}
if (category.Presets.Count != 0)
{
groupedMenu.Add(new Separator());
}
}
}
public void LoadCategoryStates()
{
StringCollection expandedPresets = this.userSettingService.GetUserSetting<StringCollection>(UserSettingConstants.PresetExpandedStateList);
if (expandedPresets == null || expandedPresets.Count == 0)
{
return;
}
foreach (IPresetObject presetObject in this.presets)
{
PresetDisplayCategory category = presetObject as PresetDisplayCategory;
if (category != null && expandedPresets.Contains(category.Category))
{
category.IsExpanded = true;
}
}
}
private void GenerateFlatList(List <object> groupedMenu, IList <IPresetObject> userPresets)
{
foreach (IPresetObject presetCategory in userPresets)
{
PresetDisplayCategory category = presetCategory as PresetDisplayCategory;
if (category != null)
{
if (groupedMenu.Count != 0 && groupedMenu.LastOrDefault()?.GetType() != typeof(Separator))
{
groupedMenu.Add(new Separator());
}
foreach (var preset in category.Presets)
{
groupedMenu.Add(GeneratePresetMenuItem(preset));
}
}
}
}
public IList <PresetDisplayCategory> GetPresetCategories(bool userCategoriesOnly)
{
List <PresetDisplayCategory> categoriesList = new List <PresetDisplayCategory>();
foreach (var item in this.Presets)
{
PresetDisplayCategory category = item as PresetDisplayCategory;
if (category != null)
{
if (userCategoriesOnly && category.IsBuiltIn)
{
continue;
}
categoriesList.Add(category);
}
}
return(categoriesList);
}
/// <summary>Converts a value. </summary>
/// <returns>A converted value. If the method returns null, the valid null value is used.</returns>
/// <param name="value">The value produced by the binding source.</param>
/// <param name="targetType">The type of the binding target property.</param>
/// <param name="parameter">The converter parameter to use.</param>
/// <param name="culture">The culture to use in the converter.</param>
public object Convert(object value, Type targetType, object parameter, CultureInfo culture)
{
IEnumerable <IPresetObject> presets = value as IEnumerable <IPresetObject>;
if (presets == null)
{
return(null);
}
Dictionary <string, object> groupedMenu = new Dictionary <string, object>();
if (parameter != null && "true".Equals(parameter))
{
MenuItem presetManagerMenuItem = new MenuItem
{
Header = Resources.PresetManger_Title,
Tag = null,
Command = new OpenPresetManagerCommand()
};
groupedMenu.Add("hb_preset_manager", presetManagerMenuItem);
groupedMenu.Add("hb_menu_separator", new Separator());
}
foreach (IPresetObject item in presets)
{
PresetDisplayCategory category = item as PresetDisplayCategory;
if (category != null)
{
ProcessCategory(groupedMenu, category);
continue;
}
Preset preset = item as Preset;
if (preset != null)
{
ProcessPreset(groupedMenu, preset);
}
}
return(groupedMenu.Values.ToList());
}
