/// <summary>
/// The export.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="preset">
/// The preset.
/// </param>
/// <param name="configuration">
/// The configuration.
/// </param>
public void Export(string filename, Preset preset, HBConfiguration configuration)
{
// TODO Add support for multiple export
PresetTransportContainer container = JsonPresetFactory.ExportPreset(preset, configuration);
HandBrakePresetService.ExportPreset(filename, container);
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="container">
/// The container.
/// </param>
public static void ExportPreset(string filename, PresetTransportContainer container)
{
string preset = JsonSerializer.Serialize(container, JsonSettings.Options);
using (StreamWriter writer = new StreamWriter(filename))
{
writer.Write(preset);
}
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="container">
/// The container.
/// </param>
public static void ExportPreset(string filename, PresetTransportContainer container)
{
string preset = JsonConvert.SerializeObject(container, Formatting.Indented);
using (StreamWriter writer = new StreamWriter(filename))
{
writer.Write(preset);
}
}
public void Export(string filename, string presetName)
{
Preset foundPreset = this.flatPresetList.FirstOrDefault(s => s.Name == presetName);
if (foundPreset != null)
{
PresetTransportContainer container = JsonPresetFactory.ExportPreset(foundPreset);
HandBrakePresetService.ExportPreset(filename, container);
}
}
private void ProcessPresetList(PresetTransportContainer container, bool ignoreOldBuiltIn)
{
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
if (preset.IsBuildIn && ignoreOldBuiltIn)
{
continue;
}
// Migration
preset.Category = category.PresetName == "User Presets" ? UserPresetCatgoryName : category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <param name="container">
/// The container.
/// </param>
public static void ExportPreset(string filename, PresetTransportContainer container)
{
string preset = JsonConvert.SerializeObject(container, Formatting.Indented, new JsonSerializerSettings {
NullValueHandling = NullValueHandling.Ignore
});
using (StreamWriter writer = new StreamWriter(filename))
{
writer.Write(preset);
}
}
/// <summary>
/// The get preset from file.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <returns>
/// The <see cref="PresetCategory"/>.
/// </returns>
public static PresetTransportContainer GetPresetFromFile(string filename)
{
IntPtr presetStringPointer = HBFunctions.hb_presets_read_file_json(InteropUtilities.ToUtf8PtrFromString(filename));
string presetJson = Marshal.PtrToStringAnsi(presetStringPointer);
log.LogMessage(presetJson, LogMessageType.API, LogLevel.Debug);
PresetTransportContainer preset = JsonConvert.DeserializeObject <PresetTransportContainer>(presetJson);
return(preset);
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = null;
try
{
container = HandBrakePresetService.GetPresetFromFile(filename);
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
return;
}
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, Resources.NoAdditionalInformation);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
foreach (var objectPreset in container.PresetList)
{
PresetCategory category = JsonConvert.DeserializeObject <PresetCategory>(objectPreset.ToString());
if (category != null && category.ChildrenArray != null && category.ChildrenArray.Count > 0)
{
foreach (HBPreset hbPreset in category.ChildrenArray)
{
Preset preset = this.ConvertHbPreset(hbPreset);
if (preset != null)
{
this.AddOrUpdateImportedPreset(preset);
}
}
}
else
{
HBPreset hbPreset = JsonConvert.DeserializeObject <HBPreset>(objectPreset.ToString());
if (hbPreset != null)
{
Preset preset = this.ConvertHbPreset(hbPreset);
if (preset != null)
{
this.AddOrUpdateImportedPreset(preset);
}
}
}
}
}
}
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="export">
/// The export.
/// </param>
/// <param name="config">
/// HandBrakes configuration options.
/// </param>
/// <returns>
/// The <see cref="Preset"/>.
/// </returns>
public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config)
{
PresetVersion presetVersion = HandBrakePresetService.GetCurrentPresetVersion();
PresetTransportContainer container = new PresetTransportContainer(presetVersion.Major, presetVersion.Minor, presetVersion.Micro);
container.PresetList = new List <object> {
CreateHbPreset(export, config)
};
return(container);
}
/// <summary>
/// Export a list of Presets.
/// </summary>
/// <param name="exportList">A list of presets to export</param>
/// <param name="config">HB's configuration</param>
/// <returns>A list of JSON object presets.</returns>
public static PresetTransportContainer ExportPresets(IEnumerable <Preset> exportList, HBConfiguration config)
{
PresetVersion presetVersion = HandBrakePresetService.GetCurrentPresetVersion();
PresetTransportContainer container = new PresetTransportContainer(presetVersion.Major, presetVersion.Minor, presetVersion.Micro);
List <HBPreset> presets = exportList.Select(item => CreateHbPreset(item, config)).ToList();
container.PresetList = new List <object>();
container.PresetList.AddRange(presets);
return(container);
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="export">
/// The export.
/// </param>
/// <param name="config">
/// HandBrakes configuration options.
/// </param>
/// <returns>
/// The <see cref="Preset"/>.
/// </returns>
public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config)
{
PresetTransportContainer container = new PresetTransportContainer();
container.VersionMajor = "0";
container.VersionMinor = "10";
container.VersionMicro = "2";
container.PresetList = new List <HBPreset> {
CreateHbPreset(export, config)
};
return(container);
}
/// <summary>
/// Update the preset files
/// </summary>
private void SavePresetFiles()
{
try
{
// Verify Directories.
string directory = Path.GetDirectoryName(this.presetFile);
if (directory != null && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// Organise the Presets list into Json Equivalent objects.
Dictionary <string, PresetCategory> presetCategories = new Dictionary <string, PresetCategory>();
List <HBPreset> uncategorisedPresets = new List <HBPreset>();
// Handle User Presets.
this.HandlePresetListsForSave(this.flatPresetList.Where(o => !o.IsBuildIn).ToList(), presetCategories, uncategorisedPresets);
// Handle Built-in Presets
this.HandlePresetListsForSave(this.flatPresetList.Where(o => o.IsBuildIn).ToList(), presetCategories, uncategorisedPresets);
// Wrap the categories in a container.
JsonSerializerSettings settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Ignore
};
PresetTransportContainer container = new PresetTransportContainer(
Constants.PresetVersionMajor,
Constants.PresetVersionMinor,
Constants.PresetVersionMicro)
{
PresetList = new List <object>()
};
container.PresetList.AddRange(presetCategories.Values);
container.PresetList.AddRange(uncategorisedPresets);
// Write the preset container out to file.
using (FileStream strm = new FileStream(this.presetFile, FileMode.Create, FileAccess.Write))
{
string presetsJson = JsonConvert.SerializeObject(container, Formatting.Indented, settings);
using (StreamWriter writer = new StreamWriter(strm))
{
writer.WriteLine(presetsJson);
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc);
throw new GeneralApplicationException("Unable to write to the presets file.", "The details section below may indicate why this error has occurred.", exc);
}
}
/// <summary>
/// The export preset.
/// </summary>
/// <param name="export">
/// The export.
/// </param>
/// <param name="config">
/// HandBrakes configuration options.
/// </param>
/// <returns>
/// The <see cref="Preset"/>.
/// </returns>
public static PresetTransportContainer ExportPreset(Preset export, HBConfiguration config)
{
PresetTransportContainer container = new PresetTransportContainer();
container.VersionMajor = Constants.PresetVersionMajor;
container.VersionMinor = Constants.PresetVersionMinor;
container.VersionMicro = Constants.PresetVersionMicro;
container.PresetList = new List <object> {
CreateHbPreset(export, config)
};
return(container);
}
/// <summary>
/// Export a list of Presets.
/// </summary>
/// <param name="exportList">A list of presets to export</param>
/// <param name="config">HB's configuration</param>
/// <returns>A list of JSON object presets.</returns>
public static PresetTransportContainer ExportPresets(IEnumerable <Preset> exportList, HBConfiguration config)
{
PresetTransportContainer container = new PresetTransportContainer();
container.VersionMajor = Constants.PresetVersionMajor;
container.VersionMinor = Constants.PresetVersionMinor;
container.VersionMicro = Constants.PresetVersionMicro;
List <HBPreset> presets = exportList.Select(item => CreateHbPreset(item, config)).ToList();
container.PresetList = new List <object>();
container.PresetList.AddRange(presets);
return(container);
}
public static PresetTransportContainer ExportPresetCategories(IList <PresetDisplayCategory> categories, HBConfiguration config)
{
PresetVersion presetVersion = HandBrakePresetService.GetCurrentPresetVersion();
PresetTransportContainer container = new PresetTransportContainer(presetVersion.Major, presetVersion.Minor, presetVersion.Micro);
List <object> presets = new List <object>();
foreach (var category in categories)
{
presets.Add(CreatePresetCategory(category, config));
}
container.PresetList = presets;
return(container);
}
/// <summary>
/// The get preset from file.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
/// <returns>
/// The <see cref="PresetCategory"/>.
/// </returns>
public static PresetTransportContainer GetPresetsFromFile(string filename)
{
IntPtr presetStringPointer = HBFunctions.hb_presets_read_file_json(InteropUtilities.ToUtf8PtrFromString(filename));
string presetJson = Marshal.PtrToStringAnsi(presetStringPointer);
if (!string.IsNullOrEmpty(presetJson))
{
// Check to see if we have a list of presets.
if (presetJson.StartsWith("["))
{
presetJson = "{ \"PresetList\":" + presetJson + " } ";
}
PresetTransportContainer preset = JsonConvert.DeserializeObject <PresetTransportContainer>(presetJson);
return(preset);
}
return(null);
}
private void ProcessPresetList(PresetTransportContainer container)
{
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserializedItem = JsonSerializer.Deserialize <HBPresetCategory>(item.ToString(), JsonSettings.Options);
// Handle Categorised Presets.
HBPresetCategory category = deserializedItem as HBPresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
// Migration
preset.Category = category.PresetName == "User Presets" ? UserPresetCategoryName : category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
this.Add(preset, true);
}
}
// Uncategorised Presets
deserializedItem = JsonSerializer.Deserialize <HBPreset>(item.ToString(), JsonSettings.Options);
HBPreset hbPreset = deserializedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCategoryName;
preset.IsBuildIn = hbPreset.Type == 0;
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
this.Add(preset, true);
}
}
}
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
this.UpdateBuiltInPresets();
return;
}
// Otherwise, we already have a file, so lets try load it.
PresetTransportContainer container = null;
try
{
container = HandBrakePresetService.GetPresetsFromFile(this.presetFile);
}
catch (Exception exc)
{
this.ServiceLogMessage("Corrupted Presets File Detected: " + Environment.NewLine + exc);
}
// Sanity Check. Did the container deserialize.
if (container?.PresetList == null)
{
this.ServiceLogMessage("Attempting Preset Recovery ...");
string filename = this.ArchivePresetFile(this.presetFile, true);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
this.ServiceLogMessage("Recovery Completed!");
return; // Update built-in presets stores the presets locally, so just return.
}
// Force Upgrade of presets
if (this.userSettingService.GetUserSetting <int>(UserSettingConstants.ForcePresetReset) < ForcePresetReset)
{
this.userSettingService.SetUserSetting(UserSettingConstants.ForcePresetReset, ForcePresetReset);
string fileName = this.ArchivePresetFile(this.presetFile, true);
this.errorService.ShowMessageBox(
Resources.Presets_PresetForceReset
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Information);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
this.ProcessPresetList(container);
PresetVersion presetVersion = HandBrakePresetService.GetCurrentPresetVersion();
if (container.VersionMajor != presetVersion.Major || container.VersionMinor != presetVersion.Minor || container.VersionMicro != presetVersion.Micro)
{
this.UpdateBuiltInPresets();
}
CheckAndSetDefault(); // Make a preset default if one we have none.
}
catch (Exception ex)
{
this.ServiceLogMessage(ex.ToString());
this.ArchivePresetFile(this.presetFile, true);
this.UpdateBuiltInPresets();
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
// TODO needs a tidy up but will do for now.
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = HandBrakePresetService.GetPresetFromFile(filename);
if (container == null || container.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
// HBPreset Handling
IList <HBPreset> hbPresets = container.PresetList as IList <HBPreset>;
if (hbPresets != null)
{
foreach (var hbPreset in hbPresets)
{
Preset preset = null;
try
{
preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
}
if (preset == null)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
// TODO Better version checking.
if (this.CheckIfPresetExists(preset.Name))
{
if (!CanUpdatePreset(preset.Name))
{
MessageBox.Show(Resources.Main_PresetErrorBuiltInName, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
MessageBoxResult result = MessageBox.Show(Resources.Main_PresetOverwriteWarning, Resources.Overwrite, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
Update(preset);
}
}
else
{
Add(preset);
}
}
}
// Category Handling.
}
}
/// <summary>
/// Load in the Built-in and User presets into the collection
/// </summary>
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
this.UpdateBuiltInPresets();
return;
}
// Otherwise, we already have a file, so lets try load it.
bool versionCheckChange = false;
using (StreamReader reader = new StreamReader(this.presetFile))
{
// New Preset Format.
PresetTransportContainer container = null;
try
{
container = JsonConvert.DeserializeObject <PresetTransportContainer>(reader.ReadToEnd());
}
catch (Exception)
{
// ignored
}
// Sanity Check. Did the container deserialise.
if (container?.PresetList == null)
{
// Close and Dispose of early.
reader.Close();
reader.Dispose();
string filename = this.RecoverFromCorruptedPresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
return;
}
// Version Check
// If we have old presets, or the container wasn't parseable, or we have a version mismatch, backup the user preset file
// incase something goes wrong.
if (container.VersionMajor != Constants.PresetVersionMajor || container.VersionMinor != Constants.PresetVersionMinor || container.VersionMicro != Constants.PresetVersionMicro)
{
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_PresetsOutOfDate
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
versionCheckChange = true;
}
// Process the presets.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());;
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
preset.Category = category.PresetName;
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.presets.Add(preset);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.presets.Add(preset);
}
}
}
// Resave the presets if we failed the version check to update the container
if (versionCheckChange)
{
this.SavePresetFiles();
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
this.RecoverFromCorruptedPresetFile(this.presetFile);
this.UpdateBuiltInPresets();
}
}
public void ExportCategories(string filename, IList <PresetDisplayCategory> categories, HBConfiguration configuration)
{
PresetTransportContainer container = JsonPresetFactory.ExportPresetCategories(categories, configuration);
HandBrakePresetService.ExportPreset(filename, container);
}
/// <summary>
/// Load in the Built-in and User presets into the collection
/// </summary>
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
this.UpdateBuiltInPresets();
return;
}
// Otherwise, we already have a file, so lets try load it.
PresetTransportContainer container = null;
using (StreamReader reader = new StreamReader(this.presetFile))
{
try
{
container = JsonConvert.DeserializeObject <PresetTransportContainer>(reader.ReadToEnd());
}
catch (Exception exc)
{
Debug.WriteLine("Failed to parse presets file: " + exc);
}
}
// Sanity Check. Did the container deserialise.
if (container == null || container.PresetList == null)
{
string filename = this.RecoverFromCorruptedPresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
return; // Update built-in presets stores the presets locally, so just return.
}
// Version Check
// If we have old presets, or the container wasn't parseable, or we have a version mismatch, backup the user preset file
// incase something goes wrong and reset built-in presets, then re-save.
bool ignoreBuildIn = false;
if (container.VersionMajor != Constants.PresetVersionMajor || container.VersionMinor != Constants.PresetVersionMinor || container.VersionMicro != Constants.PresetVersionMicro)
{
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_PresetsOutOfDate
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Information);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
ignoreBuildIn = true;
}
// Force Upgrade of presets
if (this.userSettingService.GetUserSetting <int>(UserSettingConstants.ForcePresetReset, typeof(int)) < ForcePresetReset)
{
this.userSettingService.SetUserSetting(UserSettingConstants.ForcePresetReset, ForcePresetReset);
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.Presets_PresetForceReset
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Information);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
this.ProcessPresetList(container, ignoreBuildIn);
}
catch (Exception ex)
{
Debug.WriteLine(ex);
this.RecoverFromCorruptedPresetFile(this.presetFile);
this.UpdateBuiltInPresets();
}
}
/// <summary>
/// Update the preset files
/// </summary>
private void SavePresetFiles()
{
try
{
// Verify Directories.
string directory = Path.GetDirectoryName(this.presetFile);
if (directory != null && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
// Organise the Presets list into Json Equivalent objects.
Dictionary <string, PresetCategory> presetCategories = new Dictionary <string, PresetCategory>();
List <HBPreset> uncategorisedPresets = new List <HBPreset>();
// Handle User Presets first.
foreach (Preset item in this.flatPresetList.Values.OrderBy(o => o.IsBuildIn))
{
if (string.IsNullOrEmpty(item.Category))
{
uncategorisedPresets.Add(JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create()));
}
else
{
HBPreset preset = JsonPresetFactory.CreateHbPreset(item, HBConfigurationFactory.Create());
if (presetCategories.ContainsKey(item.Category))
{
presetCategories[item.Category].ChildrenArray.Add(preset);
}
else
{
presetCategories[item.Category] = new PresetCategory
{
ChildrenArray = new List <HBPreset> {
preset
},
Folder = true,
PresetName = item.Category,
Type = item.IsBuildIn ? 0 : 1
};
}
}
}
// Wrap the categories in a container.
JsonSerializerSettings settings = new JsonSerializerSettings {
MissingMemberHandling = MissingMemberHandling.Ignore
};
PresetTransportContainer container = new PresetTransportContainer(
Constants.PresetVersionMajor,
Constants.PresetVersionMinor,
Constants.PresetVersionMicro)
{
PresetList = new List <object>()
};
container.PresetList.AddRange(presetCategories.Values);
container.PresetList.AddRange(uncategorisedPresets);
// Write the preset container out to file.
using (FileStream strm = new FileStream(this.presetFile, FileMode.Create, FileAccess.Write))
{
string presetsJson = JsonConvert.SerializeObject(container, Formatting.Indented, settings);
using (StreamWriter writer = new StreamWriter(strm))
{
writer.WriteLine(presetsJson);
}
}
}
catch (Exception exc)
{
Debug.WriteLine(exc);
throw new GeneralApplicationException("Unable to write to the presets file.", "The details section below may indicate why this error has occurred.", exc);
}
}
/// <summary>
/// Load in the Built-in and User presets into the collection
/// </summary>
private void LoadPresets()
{
// First clear the Presets arraylists
this.presets.Clear();
// Load the presets file.
try
{
// If we don't have a presets file. Create one for first load.
if (!File.Exists(this.presetFile))
{
// If this is a nightly, and we don't have a presets file, try port the main version if it exists.
string releasePresetFile = Path.Combine(DirectoryUtilities.GetUserStoragePath(false), "presets.json");
if (VersionHelper.IsNightly() && File.Exists(releasePresetFile))
{
File.Copy(releasePresetFile, DirectoryUtilities.GetUserStoragePath(true));
}
else
{
this.UpdateBuiltInPresets();
return; // Update built-in presets stores the presets locally, so just return.
}
}
// Otherwise, we already have a file, so lets try load it.
PresetTransportContainer container = null;
using (StreamReader reader = new StreamReader(this.presetFile))
{
try
{
container = JsonConvert.DeserializeObject <PresetTransportContainer>(reader.ReadToEnd());
}
catch (Exception exc)
{
Debug.WriteLine("Failed to parse presets file: " + exc);
}
}
// Sanity Check. Did the container deserialise.
if (container == null || container.PresetList == null)
{
string filename = this.RecoverFromCorruptedPresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_UnableToLoadPresets + filename,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets();
return; // Update built-in presets stores the presets locally, so just return.
}
// Version Check
// If we have old presets, or the container wasn't parseable, or we have a version mismatch, backup the user preset file
// incase something goes wrong and reset built-in presets, then re-save.
if (container.VersionMajor != Constants.PresetVersionMajor || container.VersionMinor != Constants.PresetVersionMinor || container.VersionMicro != Constants.PresetVersionMicro)
{
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.PresetService_PresetsOutOfDate
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
// Force Upgrade of presets
if (this.userSettingService.GetUserSetting <int>(UserSettingConstants.ForcePresetReset) < ForcePresetReset)
{
this.userSettingService.SetUserSetting(UserSettingConstants.ForcePresetReset, ForcePresetReset);
string fileName = this.ArchivePresetFile(this.presetFile);
this.errorService.ShowMessageBox(
Resources.Presets_PresetForceReset
+ Environment.NewLine + Environment.NewLine + Resources.PresetService_ArchiveFile + fileName,
Resources.PresetService_UnableToLoad,
MessageBoxButton.OK,
MessageBoxImage.Exclamation);
this.UpdateBuiltInPresets(); // Update built-in presets stores the presets locally, so just return.
return;
}
// The presets file loaded was OK, so process it.
foreach (var item in container.PresetList)
{
object deserialisedItem = JsonConvert.DeserializeObject <PresetCategory>(item.ToString());
// Handle Categorised Presets.
PresetCategory category = deserialisedItem as PresetCategory;
if (category != null && category.Folder)
{
foreach (HBPreset hbpreset in category.ChildrenArray)
{
Preset preset = JsonPresetFactory.ImportPreset(hbpreset);
// Migration
if (category.PresetName == "User Presets")
{
preset.Category = UserPresetCatgoryName;
}
else
{
preset.Category = category.PresetName;
}
preset.IsBuildIn = hbpreset.Type == 0;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
// Uncategorised Presets
deserialisedItem = JsonConvert.DeserializeObject <HBPreset>(item.ToString());
HBPreset hbPreset = deserialisedItem as HBPreset;
if (hbPreset != null && !hbPreset.Folder)
{
Preset preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
preset.IsBuildIn = hbPreset.Type == 1;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
this.Add(preset, true);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
this.RecoverFromCorruptedPresetFile(this.presetFile);
this.UpdateBuiltInPresets();
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = null;
try
{
container = HandBrakePresetService.GetPresetsFromFile(filename);
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
return;
}
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, Resources.NoAdditionalInformation);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
bool containsBuildInPreset = false;
foreach (var objectPreset in container.PresetList)
{
PresetCategory category = JsonConvert.DeserializeObject <PresetCategory>(objectPreset.ToString());
if (category != null && category.ChildrenArray != null && category.ChildrenArray.Count > 0)
{
foreach (HBPreset hbPreset in category.ChildrenArray)
{
Preset preset = this.ConvertHbPreset(hbPreset);
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
if (preset != null && !preset.IsBuildIn)
{
this.AddOrUpdateImportedPreset(preset);
}
else
{
containsBuildInPreset = true;
}
}
}
else
{
HBPreset hbPreset = JsonConvert.DeserializeObject <HBPreset>(objectPreset.ToString());
if (hbPreset != null)
{
Preset preset = this.ConvertHbPreset(hbPreset);
preset.IsPresetDisabled = this.IsPresetDisabled(preset);
if (preset != null && !preset.IsBuildIn)
{
this.AddOrUpdateImportedPreset(preset);
}
else
{
containsBuildInPreset = true;
}
}
}
}
if (containsBuildInPreset)
{
this.errorService.ShowMessageBox(
Properties.Resources.PresetService_ImportingBuiltInWarning,
Properties.Resources.Warning,
MessageBoxButton.OK,
MessageBoxImage.Warning);
}
}
}
}
/// <summary>
/// The import.
/// </summary>
/// <param name="filename">
/// The filename.
/// </param>
public void Import(string filename)
{
if (!string.IsNullOrEmpty(filename))
{
PresetTransportContainer container = HandBrakePresetService.GetPresetFromFile(filename);
if (container?.PresetList == null || container.PresetList.Count == 0)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
// HBPreset Handling
if (container.PresetList != null)
{
foreach (var objectPreset in container.PresetList)
{
HBPreset hbPreset = JsonConvert.DeserializeObject <HBPreset>(objectPreset.ToString());
Preset preset = null;
try
{
preset = JsonPresetFactory.ImportPreset(hbPreset);
preset.Category = UserPresetCatgoryName;
// IF we are using Source Max, Set the Max Width / Height values.
if (preset.PictureSettingsMode == PresetPictureSettingsMode.SourceMaximum)
{
preset.Task.MaxWidth = preset.Task.Height;
preset.Task.MaxHeight = preset.Task.Width;
}
}
catch (Exception exc)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, exc);
}
if (preset == null)
{
this.errorService.ShowError(Resources.Main_PresetImportFailed, Resources.Main_PresetImportFailedSolution, string.Empty);
return;
}
if (this.CheckIfPresetExists(preset.Name))
{
if (!this.CanUpdatePreset(preset.Name))
{
MessageBox.Show(Resources.Main_PresetErrorBuiltInName, Resources.Error, MessageBoxButton.OK, MessageBoxImage.Error);
return;
}
MessageBoxResult result = MessageBox.Show(Resources.Main_PresetOverwriteWarning, Resources.Overwrite, MessageBoxButton.YesNo, MessageBoxImage.Warning);
if (result == MessageBoxResult.Yes)
{
this.Update(preset);
}
}
else
{
this.Add(preset);
}
}
}
// Category Handling.
// TODO maybe for a future release.
}
}
