/// <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. } }