/* frmMain.cs $ This file is part of the HandBrake source code. Homepage: . It may be used under the terms of the GNU General Public License. */ using HandBrake.ApplicationServices.Model.Encoding; namespace Handbrake { using System; using System.Collections.Generic; using System.ComponentModel; using System.Diagnostics; using System.Drawing; using System.Globalization; using System.IO; using System.Linq; using System.Threading; using System.Windows.Forms; using Functions; using HandBrake.ApplicationServices; using HandBrake.ApplicationServices.EventArgs; using HandBrake.ApplicationServices.Exceptions; using HandBrake.ApplicationServices.Model.General; using HandBrake.ApplicationServices.Utilities; using HandBrake.ApplicationServices.Functions; using HandBrake.ApplicationServices.Model; using HandBrake.ApplicationServices.Parsing; using HandBrake.ApplicationServices.Services; using HandBrake.ApplicationServices.Services.Interfaces; using Handbrake.ToolWindows; using Model; using Ookii.Dialogs.Wpf; using Properties; using Application = System.Windows.Forms.Application; using DataFormats = System.Windows.Forms.DataFormats; using DragDropEffects = System.Windows.Forms.DragDropEffects; using DragEventArgs = System.Windows.Forms.DragEventArgs; using Main = Handbrake.Functions.Main; using MessageBox = System.Windows.Forms.MessageBox; /// /// The Main Window /// public partial class frmMain : Form { #region Private Varibles // Objects which may be used by one or more other objects ************* private IUserSettingService userSettingService = ServiceManager.UserSettingService; private IQueueProcessor queueProcessor = new QueueProcessor(Program.InstanceId); private PresetService presetHandler = new PresetService(); // Windows ************************************************************ private frmQueue queueWindow; private frmPreview qtpreview; private frmActivityWindow activityWindow; // Globals: Mainly used for tracking. ********************************* public Title selectedTitle; public string sourcePath; private SourceType selectedSourceType; private string dvdDrivePath; private string dvdDriveLabel; private Preset currentlySelectedPreset; private Source currentSource; private IScan SourceScan; private List drives; private QueueTask queueEdit; // Delegates ********************************************************** private delegate void UpdateWindowHandler(); #endregion // Applicaiton Startup ************************************************ #region Properties /// /// Gets SourceName. /// public string SourceName { get { if (this.selectedSourceType == SourceType.DvdDrive) { return this.dvdDriveLabel; } if (selectedTitle != null && !string.IsNullOrEmpty(selectedTitle.SourceName)) { return Path.GetFileName(selectedTitle.SourceName); } // We have a drive, selected as a folder. if (this.sourcePath.EndsWith("\\")) { drives = GeneralUtilities.GetDrives(); foreach (DriveInformation item in drives) { if (item.RootDirectory.Contains(this.sourcePath)) { return item.VolumeLabel; } } } if (Path.GetFileNameWithoutExtension(this.sourcePath) != "VIDEO_TS") return Path.GetFileNameWithoutExtension(this.sourcePath); return Path.GetFileNameWithoutExtension(Path.GetDirectoryName(this.sourcePath)); } } #endregion #region Application Startup /// /// Initializes a new instance of the class. /// /// /// The arguments passed in on application startup. /// public frmMain(string[] args) { InitializeComponent(); this.presetsToolStrip.Renderer = new ToolStripRenderOverride(); // We can use LibHB, if the library hb.dll exists. this.SourceScan = File.Exists("hb.dll") ? (IScan)new LibScan() : new ScanService(); lbl_libhb_warning.Visible = File.Exists("hb.dll") ? true : false; // Update the users config file with the CLI version data. Main.SetCliVersionData(); if (userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeVersion).Contains("svn")) { this.Text += " " + userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeVersion); } // Check for new versions, if update checking is enabled if (userSettingService.GetUserSetting(UserSettingConstants.UpdateStatus)) { if (DateTime.Now.Subtract(userSettingService.GetUserSetting(UserSettingConstants.LastUpdateCheckDate)).TotalDays > userSettingService.GetUserSetting(UserSettingConstants.DaysBetweenUpdateCheck)) { // Set when the last update was this.userSettingService.SetUserSetting(UserSettingConstants.LastUpdateCheckDate, DateTime.Now); string url = userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakePlatform).Contains("x86_64") ? userSettingService.GetUserSetting(UserSettingConstants.Appcast_x64) : userSettingService.GetUserSetting(UserSettingConstants.Appcast_i686); UpdateService.BeginCheckForUpdates(new AsyncCallback(UpdateCheckDone), false, url, userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeBuild), userSettingService.GetUserSetting(UserSettingConstants.Skipversion)); } } // Clear the log files in the background if (userSettingService.GetUserSetting(UserSettingConstants.ClearOldLogs)) { Thread clearLog = new Thread(() => GeneralUtilities.ClearLogFiles(30)); clearLog.Start(); } // Setup the GUI components LoadPresetPanel(); // Load the Preset Panel treeView_presets.ExpandAll(); lbl_encode.Text = string.Empty; drop_mode.SelectedIndex = 0; queueWindow = new frmQueue(this.queueProcessor, this); // Prepare the Queue if (!userSettingService.GetUserSetting(UserSettingConstants.QueryEditorTab)) tabs_panel.TabPages.RemoveAt(7); // Remove the query editor tab if the user does not want it enabled. if (userSettingService.GetUserSetting(UserSettingConstants.TooltipEnable)) ToolTip.Active = true; // Load the user's default settings or Normal Preset if (this.presetHandler.DefaultPreset != null) { this.loadPreset(this.presetHandler.DefaultPreset.Name); } else loadPreset("Normal"); // Register with Growl (if not using Growl for the encoding completion action, this wont hurt anything) GrowlCommunicator.Register(); // Event Handlers and Queue Recovery events(); Main.RecoverQueue(this.queueProcessor); // If have a file passed in via command arguemtents, check it's a file and try scanning it. if (args.Length >= 1 && (File.Exists(args[0]) || Directory.Exists(args[0]))) { this.StartScan(args[0], 0); } } /// /// When the update check is done, process the results. /// /// IAsyncResult result private void UpdateCheckDone(IAsyncResult result) { if (InvokeRequired) { Invoke(new MethodInvoker(() => UpdateCheckDone(result))); return; } try { UpdateCheckInformation info = UpdateService.EndCheckForUpdates(result); if (info.NewVersionAvailable) { UpdateInfo updateWindow = new UpdateInfo(info, userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeVersion), userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeBuild)); updateWindow.ShowDialog(); } } catch (Exception ex) { if ((bool)result.AsyncState) throw new GeneralApplicationException("Unable to check for updates.", "Please try again later. The service may currently be down or inaccessible. ", ex); } } #endregion #region Events // Encoding Events for setting up the GUI private void events() { // Handle Widget changes when preset is selected. RegisterPresetEventHandler(); // Handle Window Resize if (userSettingService.GetUserSetting(UserSettingConstants.MainWindowMinimize)) this.Resize += this.frmMain_Resize; // Handle Encode Start / Finish / Pause this.queueProcessor.EncodeService.EncodeStarted += this.encodeStarted; this.queueProcessor.EncodeService.EncodeCompleted += encodeEnded; // Scan Started and Completed Events SourceScan.ScanStatusChanged += this.SourceScanScanStatusChanged; SourceScan.ScanCompleted += this.SourceScanScanCompleted; // Handle a file being draged onto the GUI. this.DragEnter += frmMain_DragEnter; this.DragDrop += this.frmMain_DragDrop; } // Change the preset label to custom when a user changes a setting. Don't want to give the impression that users can change settings and still be using a preset private void RegisterPresetEventHandler() { // Output Settings drop_format.SelectedIndexChanged += this.changePresetLabel; check_largeFile.CheckedChanged += this.changePresetLabel; check_iPodAtom.CheckedChanged += this.changePresetLabel; check_optimiseMP4.CheckedChanged += this.changePresetLabel; // Picture Settings PictureSettings.PictureSettingsChanged += this.changePresetLabel; // Filter Settings Filters.FilterSettingsChanged += this.changePresetLabel; // Video Tab drp_videoEncoder.SelectedIndexChanged += this.changePresetLabel; check_2PassEncode.CheckedChanged += this.changePresetLabel; check_turbo.CheckedChanged += this.changePresetLabel; text_bitrate.TextChanged += this.changePresetLabel; slider_videoQuality.ValueChanged += this.changePresetLabel; // Audio Panel AudioSettings.AudioListChanged += this.changePresetLabel; // Advanced Tab x264Panel.rtf_x264Query.TextChanged += this.changePresetLabel; } private void UnRegisterPresetEventHandler() { // Output Settings drop_format.SelectedIndexChanged -= this.changePresetLabel; check_largeFile.CheckedChanged -= this.changePresetLabel; check_iPodAtom.CheckedChanged -= this.changePresetLabel; check_optimiseMP4.CheckedChanged -= this.changePresetLabel; // Picture Settings PictureSettings.PictureSettingsChanged -= this.changePresetLabel; // Filter Settings Filters.FilterSettingsChanged -= this.changePresetLabel; // Video Tab drp_videoEncoder.SelectedIndexChanged -= this.changePresetLabel; check_2PassEncode.CheckedChanged -= this.changePresetLabel; check_turbo.CheckedChanged -= this.changePresetLabel; text_bitrate.TextChanged -= this.changePresetLabel; slider_videoQuality.ValueChanged -= this.changePresetLabel; // Audio Panel AudioSettings.AudioListChanged -= this.changePresetLabel; // Advanced Tab x264Panel.rtf_x264Query.TextChanged -= this.changePresetLabel; } private void changePresetLabel(object sender, EventArgs e) { labelPreset.Text = "Output Settings (Preset: Custom)"; } private static void frmMain_DragEnter(object sender, DragEventArgs e) { if (e.Data.GetDataPresent(DataFormats.FileDrop, false)) e.Effect = DragDropEffects.All; } private void frmMain_DragDrop(object sender, DragEventArgs e) { string[] fileList = e.Data.GetData(DataFormats.FileDrop) as string[]; sourcePath = string.Empty; if (fileList != null) { if (!string.IsNullOrEmpty(fileList[0])) { this.selectedSourceType = SourceType.VideoFile; StartScan(fileList[0], 0); } else UpdateSourceLabel(); } else UpdateSourceLabel(); } private void encodeStarted(object sender, EventArgs e) { SetEncodeStarted(); this.queueProcessor.EncodeService.EncodeStatusChanged += EncodeQueue_EncodeStatusChanged; } private void encodeEnded(object sender, EventArgs e) { this.queueProcessor.EncodeService.EncodeStatusChanged -= EncodeQueue_EncodeStatusChanged; SetEncodeFinished(); } #endregion // User Interface Menus / Tool Strips ********************************* #region File Menu /// /// Kill The scan menu Item /// /// /// The sender. /// /// /// The e. /// private void mnu_killCLI_Click(object sender, EventArgs e) { KillScan(); } /// /// Exit the Application Menu Item /// /// /// The sender. /// /// /// The e. /// private void mnu_exit_Click(object sender, EventArgs e) { Application.Exit(); } #endregion #region Tools Menu /// /// Menu - Start Button /// /// /// The sender. /// /// /// The e. /// private void mnu_encode_Click(object sender, EventArgs e) { queueWindow.Show(); } /// /// Menu - Display the Log Window /// /// /// The sender. /// /// /// The e. /// private void mnu_encodeLog_Click(object sender, EventArgs e) { this.btn_ActivityWindow_Click(this, null); } /// /// Menu - Display the Options Window /// /// /// The sender. /// /// /// The e. /// private void mnu_options_Click(object sender, EventArgs e) { Form options = new frmOptions(this); options.ShowDialog(); } #endregion #region Help Menu (Toolbar) /// /// Menu - Display the User Guide Web Page /// /// The Sender /// The EventArgs private void MnuUserGuide_Click(object sender, EventArgs e) { Process.Start("http://trac.handbrake.fr/wiki/HandBrakeGuide"); } /// /// Check for Updates /// /// The Sender /// The EventArgs private void MnuCheckForUpdates_Click(object sender, EventArgs e) { lbl_updateCheck.Visible = true; this.userSettingService.SetUserSetting(UserSettingConstants.LastUpdateCheckDate, DateTime.Now); string url = userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakePlatform).Contains("x86_64") ? userSettingService.GetUserSetting(UserSettingConstants.Appcast_x64) : userSettingService.GetUserSetting(UserSettingConstants.Appcast_i686); UpdateService.BeginCheckForUpdates(new AsyncCallback(UpdateCheckDoneMenu), false, url, userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeBuild), userSettingService.GetUserSetting(UserSettingConstants.Skipversion)); } /// /// Menu - Display the About Window /// /// The Sender /// The EventArgs private void MnuAboutHandBrake_Click(object sender, EventArgs e) { using (frmAbout About = new frmAbout()) { About.ShowDialog(); } } #endregion #region Preset Bar /// /// RMenu - Expand All /// /// /// The sender. /// /// /// The e. /// private void pmnu_expandAll_Click(object sender, EventArgs e) { treeView_presets.ExpandAll(); } /// /// RMenu - Collaspe All /// /// /// The sender. /// /// /// The e. /// private void pmnu_collapse_Click(object sender, EventArgs e) { treeView_presets.CollapseAll(); } /// /// Menu - Import Preset /// /// /// The sender. /// /// /// The e. /// private void pmnu_import_Click(object sender, EventArgs e) { ImportPreset(); } /// /// RMenu - Save Changes to Preset /// /// /// The sender. /// /// /// The e. /// private void pmnu_saveChanges_Click(object sender, EventArgs e) { if (this.selectedTitle == null) { MessageBox.Show( "Please scan a source before trying to update a preset.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } DialogResult result = MessageBox.Show( "Do you wish to include picture settings when updating the preset: " + treeView_presets.SelectedNode.Text, "Update Preset", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Question); string query = QueryGenerator.GenerateQueryForPreset( this, QueryPictureSettingsMode.SourceMaximum, true, 0, 0); Preset preset = new Preset { Name = this.treeView_presets.SelectedNode.Text, Query = query, CropSettings = (result == DialogResult.Yes), AudioPassthruSettings = this.AudioSettings.PassthruSettings, Task = QueryParserUtility.Parse(query), }; presetHandler.Update(preset); } /// /// RMenu - Delete Preset /// /// /// The sender. /// /// /// The e. /// private void pmnu_delete_click(object sender, EventArgs e) { BtnRemovePreset_Click(sender, e); } /// /// Preset Menu Is Opening. Setup the Menu /// /// /// The sender. /// /// /// The e. /// private void presets_menu_Opening(object sender, CancelEventArgs e) { // Make sure that the save menu is always disabled by default pmnu_saveChanges.Enabled = false; // Now enable the save menu if the selected preset is a user preset if (treeView_presets.SelectedNode != null) pmnu_saveChanges.Enabled = presetHandler.CanUpdatePreset(treeView_presets.SelectedNode.Text); treeView_presets.Select(); } // Presets Management private void BtnAddPreset_Click(object sender, EventArgs e) { if (this.selectedTitle == null) { MessageBox.Show( "Please scan a source before trying to import a preset.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } Form preset = new frmAddPreset(this, presetHandler); if (preset.ShowDialog() == DialogResult.OK) { TreeNode presetTreeview = new TreeNode(presetHandler.LastPresetAdded.Name) { ForeColor = Color.Black }; treeView_presets.Nodes.Add(presetTreeview); presetHandler.LastPresetAdded = null; } } private void BtnRemovePreset_Click(object sender, EventArgs e) { if (treeView_presets.SelectedNode == null) { return; } DialogResult result = MessageBox.Show("Are you sure you wish to delete the selected preset?", "Preset", MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (result == DialogResult.Yes) { if (treeView_presets.SelectedNode.Nodes.Count > 0) { // Delete the selected group category this.presetHandler.RemoveGroup(treeView_presets.SelectedNode.Text.Trim()); } else { Preset preset = treeView_presets.SelectedNode.Tag as Preset; if (preset != null && preset.IsDefault) { MessageBox.Show( "Your default preset can not be deleted. It is a required preset.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Information); } // Delete the selected item. presetHandler.Remove((Preset)treeView_presets.SelectedNode.Tag); } this.LoadPresetPanel(); } treeView_presets.Select(); treeView_presets.ExpandAll(); } private void MnuSetDefaultPreset_Click(object sender, EventArgs e) { if (treeView_presets.SelectedNode != null) { Preset preset = treeView_presets.SelectedNode.Tag as Preset; if (preset != null) { MessageBox.Show( "New default preset set: " + treeView_presets.SelectedNode.Text, "Alert", MessageBoxButtons.OK, MessageBoxIcon.Information); this.presetHandler.SetDefault(preset); } } else MessageBox.Show("Please select a preset first.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } private void MnuImportPreset_Click(object sender, EventArgs e) { this.ImportPreset(); } private void MnuExportPreset_Click(object sender, EventArgs e) { this.ExportPreset(); } private void MnuResetBuiltInPresets_Click(object sender, EventArgs e) { presetHandler.UpdateBuiltInPresets(); LoadPresetPanel(); treeView_presets.ExpandAll(); } /// /// PresetBar Mouse Down event /// /// /// The sender. /// /// /// The e. /// private void treeview_presets_mouseDown(object sender, MouseEventArgs e) { if (e.Button == MouseButtons.Right) treeView_presets.SelectedNode = treeView_presets.GetNodeAt(e.Location); else if (e.Button == MouseButtons.Left) { if (treeView_presets.GetNodeAt(e.Location) != null) { if (labelPreset.Text.Contains(treeView_presets.GetNodeAt(e.Location).Text)) selectPreset(); } } treeView_presets.Select(); } /// /// Preset Bar after selecting the preset /// /// /// The sender. /// /// /// The e. /// private void treeView_presets_AfterSelect(object sender, TreeViewEventArgs e) { selectPreset(); } /// /// When the mouse moves, display a preset /// /// The Sender /// the MouseEventArgs private void TreeViewPresetsMouseMove(object sender, MouseEventArgs e) { TreeNode theNode = this.treeView_presets.GetNodeAt(e.X, e.Y); if ((theNode != null)) { // Change the ToolTip only if the pointer moved to a new node. if (theNode.ToolTipText != this.ToolTip.GetToolTip(this.treeView_presets)) { this.ToolTip.SetToolTip(this.treeView_presets, theNode.ToolTipText); } } else // Pointer is not over a node so clear the ToolTip. { this.ToolTip.SetToolTip(this.treeView_presets, string.Empty); } } /// /// Preset Bar - Handle the Delete Key /// /// /// The sender. /// /// /// The e. /// private void treeView_presets_deleteKey(object sender, KeyEventArgs e) { if (e.KeyCode == Keys.Delete) { this.BtnRemovePreset_Click(sender, e); } } /// /// Select the selected preset and setup the GUI /// private void selectPreset() { if (treeView_presets.SelectedNode != null) { // Ok, so, we've selected a preset. Now we want to load it. string presetName = treeView_presets.SelectedNode.Text; Preset preset = presetHandler.GetPreset(presetName); if (preset != null) { string query = presetHandler.GetPreset(presetName).Query; if (query != null) { // Ok, Reset all the H264 widgets before changing the preset x264Panel.Reset2Defaults(); // Now load the preset PresetLoader.LoadPreset(this, preset); // The x264 widgets will need updated, so do this now: x264Panel.StandardizeOptString(); x264Panel.SetCurrentSettingsInPanel(); // Finally, let this window have a copy of the preset settings. this.currentlySelectedPreset = preset; PictureSettings.SetPresetCropWarningLabel(preset); } } } } /// /// Load the Normal Preset /// /// /// The preset name. /// private void loadPreset(string presetName) { foreach (TreeNode treenode in treeView_presets.Nodes) { foreach (TreeNode node in treenode.Nodes) { if (node.Text.Equals(presetName)) treeView_presets.SelectedNode = node; } } } /// /// Import a plist preset /// private void ImportPreset() { if (openPreset.ShowDialog() == DialogResult.OK) { EncodeTask parsed = PlistPresetHandler.Import(openPreset.FileName); if (presetHandler.CheckIfPresetExists(parsed.PresetName)) { if (!presetHandler.CanUpdatePreset(parsed.PresetName)) { MessageBox.Show( "You can not import a preset with the same name as a built-in preset.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } DialogResult result = MessageBox.Show("This preset appears to already exist. Would you like to overwrite it?", "Overwrite preset?", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); if (result == DialogResult.Yes) { Preset preset = new Preset { Name = parsed.PresetName, Query = QueryGeneratorUtility.GenerateQuery(parsed), CropSettings = parsed.UsesPictureSettings, Description = string.Empty, AudioPassthruSettings = parsed.AllowedPassthruOptions }; presetHandler.Update(preset); } } else { Preset preset = new Preset { Name = parsed.PresetName, Query = QueryGeneratorUtility.GenerateQuery(parsed), CropSettings = parsed.UsesPictureSettings, Description = string.Empty, AudioPassthruSettings = parsed.AllowedPassthruOptions }; if (presetHandler.Add(preset)) { TreeNode preset_treeview = new TreeNode(parsed.PresetName) { ForeColor = Color.Black, Tag = preset, }; treeView_presets.Nodes.Add(preset_treeview); } } } } /// /// Export a plist Preset /// private void ExportPreset() { if (this.selectedTitle == null) { MessageBox.Show( "Please scan a source before trying to export a preset.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } SaveFileDialog savefiledialog = new SaveFileDialog { Filter = "plist|*.plist" }; if (treeView_presets.SelectedNode != null) { if (savefiledialog.ShowDialog() == DialogResult.OK) { Preset preset = presetHandler.GetPreset(treeView_presets.SelectedNode.Text); PlistPresetHandler.Export(savefiledialog.FileName, preset); } } } #endregion #region ToolStrip /// /// Toolbar - When the Source button is clicked, Clear any DVD drives and add any available DVD drives that can be used as a source. /// /// /// The sender. /// /// /// The e. /// private void btn_source_Click(object sender, EventArgs e) { // Remove old Drive Menu Items. List itemsToRemove = new List(); foreach (var item in btn_source.DropDownItems) { if (item.GetType() == typeof(ToolStripMenuItem)) { ToolStripMenuItem menuItem = (ToolStripMenuItem)item; if (menuItem.Name.StartsWith("Drive")) { itemsToRemove.Add(menuItem); } } } foreach (ToolStripMenuItem item in itemsToRemove) btn_source.DropDownItems.Remove(item); Thread driveInfoThread = new Thread(SetDriveSelectionMenuItem); driveInfoThread.Start(); } /// /// Toolbar - Start The Encode /// /// /// The sender. /// /// /// The e. /// private void btn_start_Click(object sender, EventArgs e) { if (btn_start.Text == "Stop") { DialogResult result = !userSettingService.GetUserSetting(ASUserSettingConstants.ShowCLI) ? MessageBox.Show( "Are you sure you wish to cancel the encode?\n\nPlease note: Stopping this encode will render the file unplayable. ", "Cancel Encode?", MessageBoxButtons.YesNo, MessageBoxIcon.Question) : MessageBox.Show( "Are you sure you wish to cancel the encode?", "Cancel Encode?", MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (result == DialogResult.Yes) { // Pause The Queue this.queueProcessor.Pause(); if (userSettingService.GetUserSetting(ASUserSettingConstants.ShowCLI)) this.queueProcessor.EncodeService.SafelyStop(); else this.queueProcessor.EncodeService.Stop(); } } else { // If we have a custom query, then we'll want to figure out what the new source and destination is, otherwise we'll just use the gui components. string jobSourcePath = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetSourceFromQuery(rtf_query.Text) : sourcePath; string jobDestination = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetDestinationFromQuery(rtf_query.Text) : text_destination.Text; QueueTask task = QueryGenerator.GenerateFullQuery(this); if (this.queueProcessor.QueueManager.Count != 0 || (!string.IsNullOrEmpty(jobSourcePath) && !string.IsNullOrEmpty(jobDestination))) { string specifiedQuery = rtf_query.Text != string.Empty ? rtf_query.Text : task.Query; // Check to make sure the generated query matches the GUI settings if (this.userSettingService.GetUserSetting(UserSettingConstants.PromptOnUnmatchingQueries) && !string.IsNullOrEmpty(specifiedQuery) && task.Query != specifiedQuery) { DialogResult result = MessageBox.Show("The query under the \"Query Editor\" tab " + "does not match the current GUI settings.\n\nBecause the manual query takes " + "priority over the GUI, your recently updated settings will not be taken " + "into account when encoding this job." + Environment.NewLine + Environment.NewLine + "Do you want to replace the manual query with the updated GUI-generated query?", "Manual Query does not Match GUI", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Asterisk, MessageBoxDefaultButton.Button3); switch (result) { case DialogResult.Yes: // Replace the manual query with the generated one rtf_query.Text = task.Query; break; case DialogResult.No: // Use the manual query task.Query = specifiedQuery; break; case DialogResult.Cancel: // Don't start the encode return; } } else { task.Query = specifiedQuery; } DialogResult overwrite = DialogResult.Yes; if (!string.IsNullOrEmpty(jobDestination) && File.Exists(jobDestination)) { overwrite = MessageBox.Show( "The destination file already exists. Are you sure you want to overwrite it?", "Overwrite File?", MessageBoxButtons.YesNo, MessageBoxIcon.Question); } if (overwrite == DialogResult.Yes) { if (this.queueProcessor.QueueManager.Count == 0) this.queueProcessor.QueueManager.Add(QueryGenerator.GenerateFullQuery(this)); queueWindow.SetQueue(); if (this.queueProcessor.QueueManager.Count > 1) queueWindow.Show(false); SetEncodeStarted(); // Encode is running, so setup the GUI appropriately this.queueProcessor.Start(); // Start The Queue Encoding Process } this.Focus(); } else if (string.IsNullOrEmpty(sourcePath) || string.IsNullOrEmpty(text_destination.Text)) MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } /// /// Toolbar - Add the current job to the Queue /// /// /// The sender. /// /// /// The e. /// private void btn_add2Queue_Click(object sender, EventArgs e) { // Add the item to the queue. AddItemToQueue(true); queueWindow.Show(); } /// /// Add All Scanned Titles /// /// /// The sender. /// /// /// The EventArgs. /// private void mnu_AddAllTitles_Click(object sender, EventArgs e) { AddRangeOfTitles(false); } /// /// Add a range of scanned titles /// /// /// The sender. /// /// /// The EventArgs. /// private void mnu_AddTittleRange_Click(object sender, EventArgs e) { AddRangeOfTitles(true); } /// /// Add Multiple Items to the Queue at once. /// /// /// The add Range. /// private void AddRangeOfTitles(bool addRange) { if (!this.userSettingService.GetUserSetting(UserSettingConstants.AutoNaming)) { MessageBox.Show( "You need to enable 'Auto Naming' in options to use this feature.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } if (this.SourceScan.SouceData == null) { MessageBox.Show( "You must first scan a source before you can use this feature. Select the 'Source' button on the toolbar.", "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); return; } bool errors = false; if (addRange) // Add Range { BatchAdd batchAdd = new BatchAdd(this.SourceScan.SouceData); if (batchAdd.ShowDialog() == DialogResult.OK) { TimeSpan min = batchAdd.Min; TimeSpan max = batchAdd.Max; foreach (Title title in this.SourceScan.SouceData.Titles) { if (title.Duration.TotalSeconds > min.TotalSeconds && title.Duration.TotalSeconds < max.TotalSeconds) { // Add to Queue this.drp_dvdtitle.SelectedItem = title; if (!this.AddItemToQueue(false)) { errors = true; } } } } } else // Add All { string warning = string.Format( "You are about to add *ALL* titles to the queue. \nCurrent settings will be applied to *ALL {0} Titles*. \n\nAre you sure you want to do this?", this.SourceScan.SouceData.Titles.Count); DialogResult question = MessageBox.Show( warning, "Warning", MessageBoxButtons.YesNoCancel, MessageBoxIcon.Warning); if (question == DialogResult.Yes) { foreach (Title title in this.SourceScan.SouceData.Titles) { // Add to Queue this.drp_dvdtitle.SelectedItem = title; if (!this.AddItemToQueue(false)) { errors = true; } } } } if (errors) { MessageBox.Show( "One or more items could not be added to the queue. You should check your queue and manually add any missing jobs.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } private bool AddItemToQueue(bool showError) { // If we have a custom query, then we'll want to figure out what the new source and destination is, otherwise we'll just use the gui components. string jobSourcePath = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetSourceFromQuery(rtf_query.Text) : sourcePath; string jobDestination = !string.IsNullOrEmpty(rtf_query.Text) ? Main.GetDestinationFromQuery(rtf_query.Text) : text_destination.Text; // Make sure we have a Source and Destination. if (string.IsNullOrEmpty(jobSourcePath) || string.IsNullOrEmpty(jobDestination)) { if (showError) MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); return false; } // Make sure we don't have a duplciate on the queue. if (this.queueProcessor.QueueManager.CheckForDestinationPathDuplicates(jobDestination)) { if (showError) { DialogResult result; result = MessageBox.Show( string.Format( "There is already a queue item for this destination path.\nDestination Path: {0} \n\nIf you continue, the encode will be overwritten. Do you wish to continue?", jobDestination), "Warning", MessageBoxButtons.YesNo, MessageBoxIcon.Warning); if (result != DialogResult.Yes) return false; } else { return false; } } // Add the job. QueueTask query = QueryGenerator.GenerateFullQuery(this); this.queueProcessor.QueueManager.Add(query); lbl_encode.Text = this.queueProcessor.QueueManager.Count + " encode(s) pending in the queue"; return true; } /// /// Toolbar - Show the Queue /// /// /// The sender. /// /// /// The e. /// private void btn_showQueue_Click(object sender, EventArgs e) { queueWindow.Show(); queueWindow.Activate(); } /// /// Toolbar - Show the Preview Window /// /// /// The sender. /// /// /// The e. /// private void tb_preview_Click(object sender, EventArgs e) { if (string.IsNullOrEmpty(sourcePath) || string.IsNullOrEmpty(text_destination.Text)) MessageBox.Show("No source or destination selected.", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); else { if (qtpreview == null) { qtpreview = new frmPreview(this); qtpreview.Show(); } else if (qtpreview.IsDisposed) { qtpreview = new frmPreview(this); qtpreview.Show(); } else MessageBox.Show(qtpreview, "The preview window is already open!", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } } /// /// Toolbar - Show the Activity log Window /// /// /// The sender. /// /// /// The e. /// private void btn_ActivityWindow_Click(object sender, EventArgs e) { if (this.activityWindow == null || !this.activityWindow.IsHandleCreated) this.activityWindow = new frmActivityWindow(this.queueProcessor.EncodeService, SourceScan); this.activityWindow.Show(); this.activityWindow.Activate(); } #endregion #region System Tray Icon /// /// Handle Resizing of the main window when deaing with the Notify Icon /// /// /// The sender. /// /// /// The e. /// private void frmMain_Resize(object sender, EventArgs e) { if (FormWindowState.Minimized == this.WindowState) { notifyIcon.Visible = true; this.Hide(); } else if (FormWindowState.Normal == this.WindowState) notifyIcon.Visible = false; } /// /// Double Click the Tray Icon /// /// /// The sender. /// /// /// The e. /// private void notifyIcon_MouseDoubleClick(object sender, MouseEventArgs e) { this.Visible = true; this.Activate(); this.WindowState = FormWindowState.Normal; notifyIcon.Visible = false; } /// /// Tray Icon - Restore Menu Item - Resture the Window /// /// /// The sender. /// /// /// The e. /// private void btn_restore_Click(object sender, EventArgs e) { this.Visible = true; this.Activate(); this.WindowState = FormWindowState.Normal; notifyIcon.Visible = false; } #endregion #region Main Window and Tab Control // Source private void BtnFolderScanClicked(object sender, EventArgs e) { VistaFolderBrowserDialog modernFolderDialog = new VistaFolderBrowserDialog { ShowNewFolderButton = true, RootFolder = Environment.SpecialFolder.DesktopDirectory }; this.btn_source.HideDropDown(); if (modernFolderDialog.ShowDialog() == true) { this.selectedSourceType = SourceType.Folder; SelectSource(modernFolderDialog.SelectedPath, 0); } else UpdateSourceLabel(); } private void BtnFileScanClicked(object sender, EventArgs e) { this.btn_source.HideDropDown(); if (ISO_Open.ShowDialog() == DialogResult.OK) { this.selectedSourceType = SourceType.VideoFile; SelectSource(ISO_Open.FileName, 0); } else UpdateSourceLabel(); } private void MnuDvdDriveClick(object sender, EventArgs e) { ToolStripMenuItem item = sender as ToolStripMenuItem; if (item != null) { string driveId = item.Name.Replace("Drive", string.Empty); int id; if (int.TryParse(driveId, out id)) { this.dvdDrivePath = drives[id].RootDirectory; this.dvdDriveLabel = drives[id].VolumeLabel; if (this.dvdDrivePath == null) return; this.selectedSourceType = SourceType.DvdDrive; SelectSource(this.dvdDrivePath, 0); } } } private void VideoTitleSpecificScanClick(object sender, EventArgs e) { this.btn_source.HideDropDown(); if (ISO_Open.ShowDialog() == DialogResult.OK) { this.selectedSourceType = SourceType.VideoFile; int sourceTitle = 0; TitleSpecificScan title = new TitleSpecificScan(); if (title.ShowDialog() == DialogResult.OK) { sourceTitle = title.Title; SelectSource(ISO_Open.FileName, sourceTitle); } } else UpdateSourceLabel(); } private void FolderTitleSpecificScanClick(object sender, EventArgs e) { this.btn_source.HideDropDown(); VistaFolderBrowserDialog modernFolderDialog = new VistaFolderBrowserDialog { ShowNewFolderButton = true, RootFolder = Environment.SpecialFolder.DesktopDirectory }; if (modernFolderDialog.ShowDialog() == true) { this.selectedSourceType = SourceType.Folder; int sourceTitle; TitleSpecificScan title = new TitleSpecificScan(); if (title.ShowDialog() == DialogResult.OK) { sourceTitle = title.Title; SelectSource(modernFolderDialog.SelectedPath, sourceTitle); } } else UpdateSourceLabel(); } private void SelectSource(string file, int titleSpecific) { Check_ChapterMarkers.Enabled = true; sourcePath = string.Empty; if (file == string.Empty) // Must have a file or path { UpdateSourceLabel(); return; } sourcePath = Path.GetFileName(file); StartScan(file, titleSpecific); } private void drp_dvdtitle_Click(object sender, EventArgs e) { if ((drp_dvdtitle.Items.Count == 1) && (drp_dvdtitle.Items[0].ToString() == "Automatic")) MessageBox.Show( "There are no titles to select. Please load a source file by clicking the 'Source' button above before trying to select a title.", "Alert", MessageBoxButtons.OK, MessageBoxIcon.Asterisk); } private void drp_dvdtitle_SelectedIndexChanged(object sender, EventArgs e) { UnRegisterPresetEventHandler(); drop_mode.SelectedIndex = 0; drop_chapterStart.Items.Clear(); drop_chapterFinish.Items.Clear(); if (string.IsNullOrEmpty(drp_dvdtitle.Text) || drp_dvdtitle.Text == "Automatic" || this.currentSource == null) { return; } selectedTitle = drp_dvdtitle.SelectedItem as Title; if (selectedTitle == null) { return; } lbl_duration.Text = selectedTitle.Duration.ToString(); PictureSettings.CurrentlySelectedPreset = this.currentlySelectedPreset; PictureSettings.Source = selectedTitle; // Setup Picture Settings Tab Control // Populate the Angles dropdown drop_angle.Items.Clear(); if (!userSettingService.GetUserSetting(ASUserSettingConstants.DisableLibDvdNav)) { drop_angle.Visible = true; lbl_angle.Visible = true; for (int i = 1; i <= selectedTitle.AngleCount; i++) drop_angle.Items.Add(i.ToString()); if (drop_angle.Items.Count == 0) { drop_angle.Visible = false; lbl_angle.Visible = false; } if (drop_angle.Items.Count != 0) drop_angle.SelectedIndex = 0; } else { drop_angle.Visible = false; lbl_angle.Visible = false; } // Populate the Start chapter Dropdown drop_chapterStart.Items.Clear(); drop_chapterStart.Items.AddRange(selectedTitle.Chapters.ToArray()); if (drop_chapterStart.Items.Count > 0) drop_chapterStart.Text = drop_chapterStart.Items[0].ToString(); // Populate the Final Chapter Dropdown drop_chapterFinish.Items.Clear(); drop_chapterFinish.Items.AddRange(selectedTitle.Chapters.ToArray()); if (drop_chapterFinish.Items.Count > 0) drop_chapterFinish.Text = drop_chapterFinish.Items[drop_chapterFinish.Items.Count - 1].ToString(); // Populate the Audio Channels Dropdown AudioSettings.SetTrackListAfterTitleChange(selectedTitle, this.currentlySelectedPreset); // Populate the Subtitles dropdown Subtitles.SetSubtitleTrackAuto(selectedTitle.Subtitles.ToArray()); // Update the source label if we have multiple streams if (selectedTitle != null) if (!string.IsNullOrEmpty(selectedTitle.SourceName)) labelSource.Text = Path.GetFileName(selectedTitle.SourceName); // Run the AutoName & ChapterNaming functions if (this.userSettingService.GetUserSetting(UserSettingConstants.AutoNaming)) { string autoPath = Main.AutoName(this); if (autoPath != null) text_destination.Text = autoPath; else MessageBox.Show( "You currently have \"Automatically name output files\" enabled for the destination file box, but you do not have a valid default directory set.\n\nYou should set a \"Default Path\" in HandBrakes preferences. (See 'Tools' menu -> 'Options' -> 'Output Files' Tab -> 'Default Path')", "Warning", MessageBoxButtons.OK, MessageBoxIcon.Warning); } data_chpt.Rows.Clear(); if (selectedTitle.Chapters.Count != 1) { DataGridView chapterGridView = Main.ChapterNaming(selectedTitle, data_chpt, drop_chapterFinish.Text); if (chapterGridView != null) data_chpt = chapterGridView; } else { Check_ChapterMarkers.Checked = false; Check_ChapterMarkers.Enabled = false; } // Hack to force the redraw of the scrollbars which don't resize properly when the control is disabled. data_chpt.Columns[0].Width = 166; data_chpt.Columns[0].Width = 165; RegisterPresetEventHandler(); } private void chapersChanged(object sender, EventArgs e) { if (drop_mode.SelectedIndex != 0) // Function is not used if we are not in chapters mode. return; Control ctl = (Control)sender; int chapterStart, chapterEnd; int.TryParse(drop_chapterStart.Text, out chapterStart); int.TryParse(drop_chapterFinish.Text, out chapterEnd); switch (ctl.Name) { case "drop_chapterStart": if (drop_chapterFinish.SelectedIndex == -1 && drop_chapterFinish.Items.Count != 0) drop_chapterFinish.SelectedIndex = drop_chapterFinish.Items.Count - 1; if (chapterEnd != 0) if (chapterStart > chapterEnd) drop_chapterFinish.Text = chapterStart.ToString(); break; case "drop_chapterFinish": if (drop_chapterStart.Items.Count >= 1 && drop_chapterStart.SelectedIndex == -1) drop_chapterStart.SelectedIndex = 0; if (chapterStart != 0) if (chapterEnd < chapterStart) drop_chapterFinish.Text = chapterStart.ToString(); // Add more rows to the Chapter menu if needed. if (Check_ChapterMarkers.Checked) { int i = data_chpt.Rows.Count, finish = 0; int.TryParse(drop_chapterFinish.Text, out finish); while (i < finish) { int n = data_chpt.Rows.Add(); data_chpt.Rows[n].Cells[0].Value = (i + 1); data_chpt.Rows[n].Cells[1].Value = "Chapter " + (i + 1); data_chpt.Rows[n].Cells[0].ValueType = typeof(int); data_chpt.Rows[n].Cells[1].ValueType = typeof(string); i++; } } break; } // Update the Duration lbl_duration.Text = this.selectedTitle.CalculateDuration(drop_chapterStart.SelectedIndex, drop_chapterFinish.SelectedIndex).ToString(); // Run the Autonaming function if (this.userSettingService.GetUserSetting(UserSettingConstants.AutoNaming)) text_destination.Text = Main.AutoName(this); // Disable chapter markers if only 1 chapter is selected. if (chapterStart == chapterEnd) { Check_ChapterMarkers.Enabled = false; btn_importChapters.Enabled = false; data_chpt.Enabled = false; } else { Check_ChapterMarkers.Enabled = true; if (Check_ChapterMarkers.Checked) { btn_importChapters.Enabled = true; data_chpt.Enabled = true; } } } private void SecondsOrFramesChanged(object sender, EventArgs e) { int start, end; int.TryParse(drop_chapterStart.Text, out start); int.TryParse(drop_chapterFinish.Text, out end); double duration = end - start; switch (drop_mode.SelectedIndex) { case 1: lbl_duration.Text = TimeSpan.FromSeconds(duration).ToString(); return; case 2: if (selectedTitle != null) { duration = duration / selectedTitle.Fps; lbl_duration.Text = TimeSpan.FromSeconds(duration).ToString(); } else lbl_duration.Text = "--:--:--"; return; } } private void drop_mode_SelectedIndexChanged(object sender, EventArgs e) { // Reset this.drop_chapterFinish.TextChanged -= new EventHandler(this.SecondsOrFramesChanged); this.drop_chapterStart.TextChanged -= new EventHandler(this.SecondsOrFramesChanged); // Do Work switch (drop_mode.SelectedIndex) { case 0: drop_chapterStart.DropDownStyle = ComboBoxStyle.DropDownList; drop_chapterFinish.DropDownStyle = ComboBoxStyle.DropDownList; if (drop_chapterStart.Items.Count != 0) { drop_chapterStart.SelectedIndex = 0; drop_chapterFinish.SelectedIndex = drop_chapterFinish.Items.Count - 1; } else lbl_duration.Text = "--:--:--"; return; case 1: this.drop_chapterStart.TextChanged += new EventHandler(this.SecondsOrFramesChanged); this.drop_chapterFinish.TextChanged += new EventHandler(this.SecondsOrFramesChanged); drop_chapterStart.DropDownStyle = ComboBoxStyle.Simple; drop_chapterFinish.DropDownStyle = ComboBoxStyle.Simple; if (selectedTitle != null) { drop_chapterStart.Text = "0"; drop_chapterFinish.Text = selectedTitle.Duration.TotalSeconds.ToString(); } return; case 2: this.drop_chapterStart.TextChanged += new EventHandler(this.SecondsOrFramesChanged); this.drop_chapterFinish.TextChanged += new EventHandler(this.SecondsOrFramesChanged); drop_chapterStart.DropDownStyle = ComboBoxStyle.Simple; drop_chapterFinish.DropDownStyle = ComboBoxStyle.Simple; if (selectedTitle != null) { drop_chapterStart.Text = "0"; drop_chapterFinish.Text = (selectedTitle.Fps * selectedTitle.Duration.TotalSeconds).ToString(); } return; } } // Destination private void btn_destBrowse_Click(object sender, EventArgs e) { // This removes the file extension from the filename box on the save file dialog. // It's daft but some users don't realise that typing an extension overrides the dropdown extension selected. DVD_Save.FileName = Path.GetFileNameWithoutExtension(text_destination.Text); if (Path.IsPathRooted(text_destination.Text)) DVD_Save.InitialDirectory = Path.GetDirectoryName(text_destination.Text); // Show the dialog and set the main form file path if (drop_format.SelectedIndex.Equals(0)) DVD_Save.FilterIndex = 1; else if (drop_format.SelectedIndex.Equals(1)) DVD_Save.FilterIndex = 2; if (DVD_Save.ShowDialog() == DialogResult.OK) { // Add a file extension manually, as FileDialog.AddExtension has issues with dots in filenames switch (DVD_Save.FilterIndex) { case 1: if (!Path.GetExtension(DVD_Save.FileName).Equals(".mp4", StringComparison.InvariantCultureIgnoreCase)) if (this.userSettingService.GetUserSetting(UserSettingConstants.UseM4v) == 2 || this.userSettingService.GetUserSetting(UserSettingConstants.UseM4v) == 0) DVD_Save.FileName = DVD_Save.FileName.Replace(".mp4", ".m4v").Replace(".mkv", ".m4v"); else DVD_Save.FileName = DVD_Save.FileName.Replace(".m4v", ".mp4").Replace(".mkv", ".mp4"); break; case 2: if (!Path.GetExtension(DVD_Save.FileName).Equals(".mkv", StringComparison.InvariantCultureIgnoreCase)) DVD_Save.FileName = DVD_Save.FileName.Replace(".mp4", ".mkv").Replace(".m4v", ".mkv"); break; default: // do nothing break; } text_destination.Text = DVD_Save.FileName; // Quicktime requires .m4v file for chapter markers to work. If checked, change the extension to .m4v (mp4 and m4v are the same thing) if (Check_ChapterMarkers.Checked && DVD_Save.FilterIndex != 2) SetExtension(".m4v"); } } private void text_destination_TextChanged(object sender, EventArgs e) { string path = text_destination.Text; if (path.EndsWith(".mp4") || path.EndsWith(".m4v")) drop_format.SelectedIndex = 0; else if (path.EndsWith(".mkv")) drop_format.SelectedIndex = 1; } // Output Settings private void drop_format_SelectedIndexChanged(object sender, EventArgs e) { switch (drop_format.SelectedIndex) { case 0: SetExtension(".mp4"); break; case 1: SetExtension(".mkv"); break; } AudioSettings.SetContainer(drop_format.Text); if (drop_format.Text.Contains("MP4") && drp_videoEncoder.Items.Contains("VP3 (Theora)")) { drp_videoEncoder.Items.Remove("VP3 (Theora)"); if (drp_videoEncoder.SelectedItem == null) { drp_videoEncoder.SelectedIndex = 0; } } else if (drop_format.Text.Contains("MKV") && !drp_videoEncoder.Items.Contains("VP3 (Theora)")) { drp_videoEncoder.Items.Add("VP3 (Theora)"); } } public void SetExtension(string newExtension) { setContainerOpts(); if (newExtension == ".mp4" || newExtension == ".m4v") if (Check_ChapterMarkers.Checked || AudioSettings.RequiresM4V() || Subtitles.RequiresM4V() || this.userSettingService.GetUserSetting(UserSettingConstants.UseM4v) == 2) newExtension = this.userSettingService.GetUserSetting(UserSettingConstants.UseM4v) == 1 ? ".mp4" : ".m4v"; else newExtension = ".mp4"; if (Path.HasExtension(newExtension)) text_destination.Text = Path.ChangeExtension(text_destination.Text, newExtension); } // Video Tab private void drp_videoEncoder_SelectedIndexChanged(object sender, EventArgs e) { // Turn off some options which are H.264 only when the user selects a non h.264 encoder if (drp_videoEncoder.Text.Contains("H.264")) { if (check_2PassEncode.CheckState == CheckState.Checked) check_turbo.Enabled = true; if ((drop_format.Text.Contains("MP4")) || (drop_format.Text.Contains("M4V"))) check_iPodAtom.Enabled = true; else check_iPodAtom.Enabled = false; } else { check_turbo.CheckState = CheckState.Unchecked; check_turbo.Enabled = false; x264Panel.X264Query = string.Empty; check_iPodAtom.Enabled = false; check_iPodAtom.Checked = false; } // Setup the CQ Slider and Advanced Panel switch (drp_videoEncoder.Text) { case "MPEG-4 (FFmpeg)": case "MPEG-2 (FFmpeg)": if (slider_videoQuality.Value > 31) slider_videoQuality.Value = 20; // Just reset to 70% QP 10 on encode change. slider_videoQuality.Minimum = 1; slider_videoQuality.Maximum = 31; this.x264Panel.Visible = false; this.advancedEncoderOpts.Visible = true; this.advancedEncoderOpts.IsDisabled = false; break; case "H.264 (x264)": slider_videoQuality.Minimum = 0; slider_videoQuality.TickFrequency = 1; double cqStep = userSettingService.GetUserSetting(ASUserSettingConstants.X264Step); double multiplier = 1.0 / cqStep; double value = slider_videoQuality.Value * multiplier; slider_videoQuality.Maximum = (int)(51 / userSettingService.GetUserSetting(ASUserSettingConstants.X264Step)); if (value < slider_videoQuality.Maximum) slider_videoQuality.Value = slider_videoQuality.Maximum - (int)value; this.x264Panel.Visible = true; this.x264Panel.BringToFront(); this.advancedEncoderOpts.Visible = false; break; case "VP3 (Theora)": if (slider_videoQuality.Value > 63) slider_videoQuality.Value = 45; // Just reset to 70% QP 45 on encode change. slider_videoQuality.Minimum = 0; slider_videoQuality.Maximum = 63; this.x264Panel.Visible = false; this.advancedEncoderOpts.Visible = true; this.advancedEncoderOpts.IsDisabled = true; break; } } /// /// When the FrameRate is not Same As Source, show the Max/Constant Mode dropdown /// /// /// The sender. /// /// /// The e. /// private void drp_videoFramerate_SelectedIndexChanged(object sender, EventArgs e) { this.radio_peakAndVariable.Text = this.drp_videoFramerate.SelectedIndex == 0 ? "Variable Framerate" : "Peak Framerate (VFR)"; } /// /// Set the container format options /// public void setContainerOpts() { if ((drop_format.Text.Contains("MP4")) || (drop_format.Text.Contains("M4V"))) { check_largeFile.Enabled = true; check_optimiseMP4.Enabled = true; check_iPodAtom.Enabled = true; } else { check_largeFile.Enabled = false; check_optimiseMP4.Enabled = false; check_iPodAtom.Enabled = false; check_largeFile.Checked = false; check_optimiseMP4.Checked = false; check_iPodAtom.Checked = false; } } private double cachedCqStep; /// /// Update the CQ slider for x264 for a new CQ step. This is set from option /// public void setQualityFromSlider() { if (cachedCqStep == 0) { cachedCqStep = userSettingService.GetUserSetting(ASUserSettingConstants.X264Step); } // Work out the current RF value. double cqStep = this.cachedCqStep; double rfValue = 51.0 - slider_videoQuality.Value * cqStep; // Change the maximum value for the slider slider_videoQuality.Maximum = (int)(51 / userSettingService.GetUserSetting(ASUserSettingConstants.X264Step)); // Reset the CQ slider to RF0 slider_videoQuality.Value = slider_videoQuality.Maximum; // Reset the CQ slider back to the previous value as close as possible double cqStepNew = userSettingService.GetUserSetting(ASUserSettingConstants.X264Step); double rfValueCurrent = 51.0 - slider_videoQuality.Value * cqStepNew; while (rfValueCurrent < rfValue) { slider_videoQuality.Value--; rfValueCurrent = 51.0 - slider_videoQuality.Value * cqStepNew; } // Cache the CQ step for the next calculation this.cachedCqStep = userSettingService.GetUserSetting(ASUserSettingConstants.X264Step); } private void slider_videoQuality_Scroll(object sender, EventArgs e) { double cqStep = userSettingService.GetUserSetting(ASUserSettingConstants.X264Step); switch (drp_videoEncoder.Text) { case "MPEG-4 (FFmpeg)": case "MPEG-2 (FFmpeg)": lbl_SliderValue.Text = "QP:" + (32 - slider_videoQuality.Value); break; case "H.264 (x264)": double rfValue = 51.0 - slider_videoQuality.Value * cqStep; rfValue = Math.Round(rfValue, 2); lbl_SliderValue.Text = "RF:" + rfValue.ToString(CultureInfo.InvariantCulture); if (rfValue == 0) { lbl_SliderValue.Text += " (Warning: lossless)"; } break; case "VP3 (Theora)": lbl_SliderValue.Text = "QP:" + slider_videoQuality.Value; break; } } private void radio_avgBitrate_CheckedChanged(object sender, EventArgs e) { if (radio_avgBitrate.Checked) { text_bitrate.Enabled = true; if (string.IsNullOrEmpty(text_bitrate.Text)) { text_bitrate.Text = "1500"; } slider_videoQuality.Enabled = false; check_2PassEncode.Enabled = true; } } private void radio_cq_CheckedChanged(object sender, EventArgs e) { text_bitrate.Enabled = false; slider_videoQuality.Enabled = true; check_2PassEncode.Enabled = false; check_2PassEncode.CheckState = CheckState.Unchecked; } private void check_2PassEncode_CheckedChanged(object sender, EventArgs e) { if (check_2PassEncode.CheckState.ToString() == "Checked") { if (drp_videoEncoder.Text.Contains("H.264")) check_turbo.Enabled = true; } else { check_turbo.Enabled = false; check_turbo.CheckState = CheckState.Unchecked; } } // Chapter Marker Tab private void Check_ChapterMarkers_CheckedChanged(object sender, EventArgs e) { if (Check_ChapterMarkers.Checked) { if (drop_format.SelectedIndex != 1) SetExtension(".m4v"); data_chpt.Enabled = true; btn_importChapters.Enabled = true; } else { if (drop_format.SelectedIndex != 1) SetExtension(".mp4"); data_chpt.Enabled = false; btn_importChapters.Enabled = false; } } private void btn_importChapters_Click(object sender, EventArgs e) { if (File_ChapterImport.ShowDialog() == DialogResult.OK) { string filename = File_ChapterImport.FileName; DataGridView imported = Main.ImportChapterNames(data_chpt, filename); if (imported != null) data_chpt = imported; } } private void btn_export_Click(object sender, EventArgs e) { SaveFileDialog saveFileDialog = new SaveFileDialog(); saveFileDialog.Filter = "Csv File|*.csv"; saveFileDialog.DefaultExt = "csv"; if (saveFileDialog.ShowDialog() == DialogResult.OK) { string filename = saveFileDialog.FileName; Main.SaveChapterMarkersToCsv(this, filename); } } private void mnu_resetChapters_Click(object sender, EventArgs e) { data_chpt.Rows.Clear(); DataGridView chapterGridView = Main.ChapterNaming(selectedTitle, data_chpt, drop_chapterFinish.Text); if (chapterGridView != null) { data_chpt = chapterGridView; } } // Query Editor Tab private void btn_generate_Query_Click(object sender, EventArgs e) { rtf_query.Text = QueryGenerator.GenerateFullQuery(this).Query; } private void btn_clear_Click(object sender, EventArgs e) { rtf_query.Clear(); } #endregion // MainWindow Components, Actions and Functions *********************** #region Source Scan /// /// Start the Scan Process /// /// /// The filename. /// /// /// The title. /// private void StartScan(string filename, int title) { // Setup the GUI components for the scan. sourcePath = filename; this.DisableGUI(); // Start the Scan try { SourceScan.Scan(sourcePath, title, this.userSettingService.GetUserSetting(ASUserSettingConstants.PreviewScanCount)); } catch (Exception exc) { MessageBox.Show("frmMain.cs - StartScan " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } /// /// Update the Status label for the scan /// /// /// The sender. /// /// /// The e. /// private void SourceScanScanStatusChanged(object sender, ScanProgressEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new ScanProgessStatus(this.SourceScanScanStatusChanged), new[] { sender, e }); return; } labelSource.Text = string.Format("Processing Title: {0} of {1}", e.CurrentTitle, e.Titles); } /// /// Update the UI after the scan has completed /// /// /// The sender. /// /// /// The e. /// private void SourceScanScanCompleted(object sender, EventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new ScanCompletedStatus(this.SourceScanScanCompleted), new[] { sender, e }); return; } try { currentSource = SourceScan.SouceData; // Setup some GUI components drp_dvdtitle.Items.Clear(); if (currentSource.Titles.Count != 0) drp_dvdtitle.Items.AddRange(currentSource.Titles.ToArray()); foreach (Title title in currentSource.Titles) { if (title.MainTitle) { drp_dvdtitle.SelectedItem = title; } } if (drp_dvdtitle.SelectedItem == null && drp_dvdtitle.Items.Count > 0) { drp_dvdtitle.SelectedIndex = 0; } // Enable the creation of chapter markers if the file is an image of a dvd if (drop_chapterStart.Items.Count > 0) { int start, end; int.TryParse(drop_chapterStart.Items[0].ToString(), out start); int.TryParse(drop_chapterFinish.Items[drop_chapterFinish.Items.Count - 1].ToString(), out end); if (end > start) Check_ChapterMarkers.Enabled = true; else { Check_ChapterMarkers.Enabled = false; Check_ChapterMarkers.Checked = false; data_chpt.Rows.Clear(); } } // If no titles were found, Display an error message if (drp_dvdtitle.Items.Count == 0) { MessageBox.Show( "No Title(s) found. \n\nYour Source may be copy protected, badly mastered or in a format which HandBrake does not support. \nPlease refer to the Documentation and FAQ (see Help Menu).", "Error", MessageBoxButtons.OK, MessageBoxIcon.Hand); sourcePath = string.Empty; } UpdateSourceLabel(); // This is a bit of a hack to fix the queue editing. // If afte the scan, we find a job sitting in queueEdit, then the user has rescaned the source from the queue by clicking edit. // When this occures, we want to repopulate their old settings. if (queueEdit != null) { // Setup UI if (queueEdit.Query != null) { Preset preset = new Preset { Name = "Loaded Back From Queue", Query = queueEdit.Query, CropSettings = true, }; // Now load the preset PresetLoader.LoadPreset(this, preset); preset.Task = queueEdit.Task; this.AudioSettings.LoadTracks(preset); // Set the destination path); this.text_destination.Text = queueEdit.Destination; // The x264 widgets will need updated, so do this now: x264Panel.StandardizeOptString(); x264Panel.SetCurrentSettingsInPanel(); // Set the crop label PictureSettings.SetPresetCropWarningLabel(null); } queueEdit = null; } // Enable the GUI components and enable any disabled components EnableGUI(); } catch (Exception exc) { MessageBox.Show("frmMain.cs - updateUIafterScan " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); EnableGUI(); } } /// /// Enable the GUI /// private void EnableGUI() { try { if (InvokeRequired) BeginInvoke(new UpdateWindowHandler(EnableGUI)); foreach (Control ctrl in Controls) ctrl.Enabled = true; btn_start.Enabled = true; btn_showQueue.Enabled = true; btn_add2Queue.Enabled = true; tb_preview.Enabled = true; btn_source.Enabled = true; mnu_killCLI.Visible = false; } catch (Exception exc) { MessageBox.Show("frmMain.cs - EnableGUI() " + exc, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } /// /// Disable the GUI /// private void DisableGUI() { foreach (Control ctrl in Controls) if (!(ctrl is StatusStrip || ctrl is MenuStrip || ctrl is ToolStrip)) ctrl.Enabled = false; labelSource.Enabled = true; labelStaticSource.Enabled = true; SourceLayoutPanel.Enabled = true; btn_source.Enabled = false; btn_start.Enabled = false; btn_showQueue.Enabled = false; btn_add2Queue.Enabled = false; tb_preview.Enabled = false; mnu_killCLI.Visible = true; } /// /// Kill the Scan /// private void KillScan() { SourceScan.ScanCompleted -= this.SourceScanScanCompleted; EnableGUI(); ResetGUI(); SourceScan.Stop(); labelSource.Text = "Scan Cancelled"; } /// /// Reset the GUI /// private void ResetGUI() { drp_dvdtitle.Items.Clear(); drop_chapterStart.Items.Clear(); drop_chapterFinish.Items.Clear(); lbl_duration.Text = "Select a Title"; PictureSettings.lbl_src_res.Text = "Select a Title"; sourcePath = String.Empty; text_destination.Text = String.Empty; selectedTitle = null; } /// /// Update the Source Label /// private void UpdateSourceLabel() { labelSource.Text = string.IsNullOrEmpty(sourcePath) ? "Select \"Source\" to continue." : this.SourceName; } /// /// Take a job from the Queue, rescan it, and reload the GUI for that job. /// /// /// The job. /// public void RecievingJob(QueueTask job) { // Reset this.currentlySelectedPreset = null; x264Panel.Reset2Defaults(); // Scan queueEdit = job; // Nasty but will do for now. TODO StartScan(job.Source, job.Title); } #endregion #region GUI Functions and Actions /// /// Set the GUI to it's finished encoding state. /// private void SetEncodeFinished() { try { if (InvokeRequired) { BeginInvoke(new UpdateWindowHandler(SetEncodeFinished)); return; } lbl_encode.Text = "Encoding Finished"; ProgressBarStatus.Visible = false; btn_start.Text = "Start"; btn_start.ToolTipText = "Start the encoding process"; btn_start.Image = Properties.Resources.Play; // If the window is minimized, display the notification in a popup. if (this.userSettingService.GetUserSetting(UserSettingConstants.TrayIconAlerts)) if (FormWindowState.Minimized == this.WindowState) { notifyIcon.BalloonTipText = lbl_encode.Text; notifyIcon.ShowBalloonTip(500); } } catch (Exception exc) { MessageBox.Show(exc.ToString()); } } /// /// Set the GUI to it's started encoding state. /// private void SetEncodeStarted() { try { if (InvokeRequired) { BeginInvoke(new UpdateWindowHandler(SetEncodeStarted)); return; } lbl_encode.Visible = true; ProgressBarStatus.Value = 0; ProgressBarStatus.Visible = true; lbl_encode.Text = "Encoding with " + this.queueProcessor.QueueManager.Count + " encode(s) pending"; btn_start.Text = "Stop"; btn_start.ToolTipText = "Stop the encoding process."; btn_start.Image = Properties.Resources.stop; } catch (Exception exc) { MessageBox.Show(exc.ToString()); } } /// /// Display the Encode Status /// /// /// The sender. /// /// /// The e. /// private void EncodeQueue_EncodeStatusChanged(object sender, EncodeProgressEventArgs e) { if (this.InvokeRequired) { this.BeginInvoke(new EncodeProgessStatus(EncodeQueue_EncodeStatusChanged), new[] { sender, e }); return; } lbl_encode.Text = string.Format( "{0:00.00}%, FPS: {1:000.0}, Avg FPS: {2:000.0}, Time Remaining: {3}, Elapsed: {4:hh\\:mm\\:ss}, Pending Jobs {5}", e.PercentComplete, e.CurrentFrameRate, e.AverageFrameRate, e.EstimatedTimeLeft, e.ElapsedTime, this.queueProcessor.QueueManager.Count); ProgressBarStatus.Value = (int)Math.Round(e.PercentComplete); } /// /// Set the DVD Drive selection in the "Source" Menu /// private void SetDriveSelectionMenuItem() { try { if (InvokeRequired) { BeginInvoke(new UpdateWindowHandler(SetDriveSelectionMenuItem)); return; } drives = GeneralUtilities.GetDrives(); List menuItems = new List(); foreach (DriveInformation drive in drives) { ToolStripMenuItem menuItem = new ToolStripMenuItem { Name = drive.ToString(), Text = drive.RootDirectory + " (" + drive.VolumeLabel + ")", Image = Resources.disc_small }; menuItem.Click += new EventHandler(MnuDvdDriveClick); menuItems.Add(menuItem); } foreach (ToolStripMenuItem item in menuItems) btn_source.DropDownItems.Add(item); } catch (Exception exc) { MessageBox.Show("Error in SetDriveSelectionMenuItem" + exc); } } /// /// Access the preset Handler and setup the preset panel. /// private void LoadPresetPanel() { if (presetHandler.CheckIfPresetsAreOutOfDate()) if (!this.userSettingService.GetUserSetting(UserSettingConstants.PresetNotification)) MessageBox.Show(this, "HandBrake has determined your built-in presets are out of date... These presets will now be updated.", "Preset Update", MessageBoxButtons.OK, MessageBoxIcon.Information); // Clear the old presets treeView_presets.Nodes.Clear(); string category = string.Empty; // The category we are currnetly processing TreeNode rootNode = null; foreach (Preset preset in this.presetHandler.Presets.Where(p => p.IsBuildIn)) { // If the category of this preset doesn't match the current category we are processing // Then we need to create a new root node. if (preset.Category != category) { rootNode = new TreeNode(preset.Category) { ForeColor = Color.DarkBlue }; treeView_presets.Nodes.Add(rootNode); category = preset.Category; } if (preset.Category == category && rootNode != null) rootNode.Nodes.Add(new TreeNode(preset.Name) { ToolTipText = preset.Description, ForeColor = Color.DarkBlue, Tag = preset }); } rootNode = null; category = null; foreach (Preset preset in this.presetHandler.Presets.Where(p => !p.IsBuildIn)) // User Presets { // If the category of this preset doesn't match the current category we are processing // Then we need to create a new root node. if (preset.Category != category && preset.Category != string.Empty) { rootNode = new TreeNode(preset.Category) { ForeColor = Color.Black }; treeView_presets.Nodes.Add(rootNode); category = preset.Category; } if (preset.Category == category && rootNode != null) rootNode.Nodes.Add(new TreeNode(preset.Name) { ForeColor = Color.Black, ToolTipText = preset.Description, Tag = preset }); else treeView_presets.Nodes.Add(new TreeNode(preset.Name) { ForeColor = Color.Black, ToolTipText = preset.Description, Tag = preset }); } treeView_presets.Update(); } /// /// Get the title from the selected item in the title dropdown. /// /// /// The title. /// public int GetTitle() { int title = 0; if (drp_dvdtitle.SelectedItem != null) { string[] titleInfo = drp_dvdtitle.SelectedItem.ToString().Split(' '); int.TryParse(titleInfo[0], out title); } return title; } /// /// Handle the Update Check Finishing. /// /// /// The result. /// private void UpdateCheckDoneMenu(IAsyncResult result) { // Make sure it's running on the calling thread if (InvokeRequired) { Invoke(new MethodInvoker(() => this.UpdateCheckDoneMenu(result))); return; } UpdateCheckInformation info; try { // Get the information about the new build, if any, and close the window info = UpdateService.EndCheckForUpdates(result); if (info.NewVersionAvailable) { UpdateInfo updateWindow = new UpdateInfo(info, userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeVersion), userSettingService.GetUserSetting(ASUserSettingConstants.HandBrakeBuild)); updateWindow.ShowDialog(); } else MessageBox.Show("There are no new updates at this time.", "Update Check", MessageBoxButtons.OK, MessageBoxIcon.Information); lbl_updateCheck.Visible = false; return; } catch (Exception ex) { if ((bool)result.AsyncState) MessageBox.Show( "Unable to check for updates, Please try again later.\n\nDetailed Error Information:\n" + ex, "Error", MessageBoxButtons.OK, MessageBoxIcon.Error); } } #endregion #region Overrides /// /// Handle GUI shortcuts /// /// Message /// Keys /// Bool protected override bool ProcessCmdKey(ref Message msg, Keys keyData) { if (keyData == (Keys.Control | Keys.S)) { btn_start_Click(this, new EventArgs()); return true; } if (keyData == (Keys.Control | Keys.Shift | Keys.A)) { btn_add2Queue_Click(this, new EventArgs()); return true; } return base.ProcessCmdKey(ref msg, keyData); } /// /// If the queue is being processed, prompt the user to confirm application close. /// /// FormClosingEventArgs protected override void OnFormClosing(FormClosingEventArgs e) { try { // If currently encoding, the queue isn't paused, and there are queue items to process, prompt to confirm close. if (this.queueProcessor.EncodeService.IsEncoding) { DialogResult result = MessageBox.Show( "HandBrake is currently encoding. Closing HandBrake will stop the current encode and will result in an unplayable file.\n\nDo you want to close HandBrake?", "Close HandBrake?", MessageBoxButtons.YesNo, MessageBoxIcon.Question); if (result == DialogResult.No) { e.Cancel = true; return; } this.queueProcessor.Pause(); this.queueProcessor.EncodeService.Stop(); } if (SourceScan.IsScanning) { SourceScan.Stop(); } SourceScan.ScanCompleted -= this.SourceScanScanCompleted; SourceScan.ScanStatusChanged -= this.SourceScanScanStatusChanged; } catch (Exception exc) { throw new GeneralApplicationException("HandBrake was not able to shutdown properly.", " You may need to forcefully quit HandBrake CLI from TaskManager if it's still running ", exc); } finally { base.OnFormClosing(e); } } #endregion // This is the END of the road **************************************** } }