-

mpv.net/Misc/Addon.cs

@@ -0,0 +1,51 @@
+using System;
+using System.Collections.Generic;
+using System.ComponentModel.Composition;
+using System.ComponentModel.Composition.Hosting;
+using System.IO;
+using System.Windows.Forms;
+
+namespace mpvnet
+{
+    public class Addon
+    {
+        [ImportMany]
+        public IEnumerable<IAddon> Addons = null;
+
+        readonly CompositionContainer CompositionContainer;
+
+        public Addon()
+        {
+            try
+            {
+                AggregateCatalog catalog = new AggregateCatalog();
+
+                string dir = Application.StartupPath + "\\Addons";
+
+                if (Directory.Exists(dir))
+                    foreach (string i in Directory.GetDirectories(dir))
+                        catalog.Catalogs.Add(new DirectoryCatalog(i, "*Addon.dll"));
+
+                dir = mp.MpvConfFolder + "\\Addons";
+
+                if (Directory.Exists(dir))
+                    foreach (string i in Directory.GetDirectories(dir))
+                        catalog.Catalogs.Add(new DirectoryCatalog(i, "*Addon.dll"));
+
+                if (catalog.Catalogs.Count > 0)
+                {
+                    CompositionContainer = new CompositionContainer(catalog);
+                    CompositionContainer.ComposeParts(this);
+                }
+            }
+            catch (Exception ex)
+            {
+                Msg.ShowException(ex);
+            }
+        }
+    }
+
+    public interface IAddon
+    {
+    }
+}

mpv.net/Misc/Command.cs

@@ -0,0 +1,275 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Windows.Forms;
+using System.Windows.Interop;
+
+namespace mpvnet
+{
+    public class Command
+    {
+        public string Name { get; set; }
+        public Action<string[]> Action { get; set; }
+
+        static List<Command> commands;
+
+        public static List<Command> Commands
+        {
+            get
+            {
+                if (commands == null)
+                {
+                    commands = new List<Command>();
+                    Type type = typeof(Command);
+                    MethodInfo[] methods = type.GetMethods(System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public);
+
+                    foreach (MethodInfo i in methods)
+                    {
+                        ParameterInfo[] parameters = i.GetParameters();
+
+                        if (parameters == null || parameters.Length != 1 || parameters[0].ParameterType != typeof(string[]))
+                            continue;
+
+                        Command cmd = new Command() { Name = i.Name.Replace("_","-"), Action = (Action<string[]>)i.CreateDelegate(typeof(Action<string[]>)) };
+                        commands.Add(cmd);
+                    }
+                }
+                return commands;
+            }
+        }
+
+        public static void open_files(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                using (var d = new OpenFileDialog() { Multiselect = true })
+                    if (d.ShowDialog() == DialogResult.OK)
+                        mp.LoadFiles(d.FileNames);
+            }));
+        }
+
+        public static void open_conf_folder(string[] args)
+        {
+            Process.Start(mp.MpvConfFolder);
+        }
+
+        public static void show_input_editor(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                InputWindow w = new InputWindow();
+                new WindowInteropHelper(w).Owner = MainForm.Instance.Handle;
+                w.ShowDialog();
+            }));
+        }
+
+        public static void show_conf_editor(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                ConfWindow w = new ConfWindow();
+                new WindowInteropHelper(w).Owner = MainForm.Instance.Handle;
+                w.ShowDialog();
+            }));
+        }
+
+        public static void show_about(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                AboutWindow w = new AboutWindow();
+                new WindowInteropHelper(w).Owner = MainForm.Instance.Handle;
+                w.ShowDialog();
+            }));
+        }
+
+        public static void show_command_palette(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                var w = new CommandPaletteWindow();
+                new WindowInteropHelper(w).Owner = MainForm.Instance.Handle;
+                w.ShowDialog();
+            }));
+        }
+
+        public static void show_media_search(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                var w = new EverythingWindow();
+                new WindowInteropHelper(w).Owner = MainForm.Instance.Handle;
+                w.ShowDialog();
+            }));
+        }
+
+        public static void show_history(string[] args)
+        {
+            var fp = mp.MpvConfFolder + "history.txt";
+
+            if (File.Exists(fp))
+                Process.Start(fp);
+            else
+                if (Msg.ShowQuestion("Create history.txt file in config folder?",
+                    "mpv.net will write the date, time and filename of opened files to it.") == MsgResult.OK)
+                    File.WriteAllText(fp, "");
+        }
+
+        public static void shell_execute(string[] args) => Process.Start(args[0]);
+
+        public static void show_info(string[] args)
+        {
+            try
+            {
+                string performer, title, album, genre, date, duration, text = "";
+                long fileSize = 0;
+                string path = mp.get_property_string("path");
+                int width = mp.get_property_int("video-params/w");
+                int height = mp.get_property_int("video-params/h");
+
+                if (File.Exists(path))
+                {
+                    fileSize = new FileInfo(path).Length;
+
+                    if (App.AudioTypes.Contains(Path.GetExtension(path).ToLower().TrimStart('.')))
+                    {
+                        using (MediaInfo mediaInfo = new MediaInfo(path))
+                        {
+                            performer = mediaInfo.GetInfo(MediaInfoStreamKind.General, "Performer");
+                            title = mediaInfo.GetInfo(MediaInfoStreamKind.General, "Title");
+                            album = mediaInfo.GetInfo(MediaInfoStreamKind.General, "Album");
+                            genre = mediaInfo.GetInfo(MediaInfoStreamKind.General, "Genre");
+                            date = mediaInfo.GetInfo(MediaInfoStreamKind.General, "Recorded_Date");
+                            duration = mediaInfo.GetInfo(MediaInfoStreamKind.Audio, "Duration/String");
+
+                            if (performer != "") text += "Artist: " + performer + "\n";
+                            if (title != "") text += "Title: " + title + "\n";
+                            if (album != "") text += "Album: " + album + "\n";
+                            if (genre != "") text += "Genre: " + genre + "\n";
+                            if (date != "") text += "Year: " + date + "\n";
+                            if (duration != "") text += "Length: " + duration + "\n";
+
+                            mp.commandv("show-text", text, "5000");
+                            return;
+                        }
+                    }
+                }
+
+                TimeSpan position = TimeSpan.FromSeconds(mp.get_property_number("time-pos"));
+                TimeSpan duration2 = TimeSpan.FromSeconds(mp.get_property_number("duration"));
+                string videoCodec = mp.get_property_string("video-format").ToUpper();
+
+                text = Path.GetFileName(path) + "\n" +
+                    FormatTime(position.TotalMinutes) + ":" +
+                    FormatTime(position.Seconds) + " / " +
+                    FormatTime(duration2.TotalMinutes) + ":" +
+                    FormatTime(duration2.Seconds) + "\n" +
+                    $"{width} x {height}\n";
+
+                if (fileSize > 0)
+                    text += Convert.ToInt32(fileSize / 1024.0 / 1024.0).ToString() + " MB\n";
+
+                text += $"{videoCodec}\n";
+
+                mp.commandv("show-text", text, "5000");
+                string FormatTime(double value) => ((int)value).ToString("00");
+            }
+            catch (Exception)
+            {
+            }
+        }
+
+        public static void execute_mpv_command(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                string command = Microsoft.VisualBasic.Interaction.InputBox("Enter a mpv command to be executed.", "Execute Command", RegistryHelp.GetString("HKCU\\Software\\" + Application.ProductName, "RecentExecutedCommand"));
+                if (string.IsNullOrEmpty(command)) return;
+                RegistryHelp.SetObject("HKCU\\Software\\" + Application.ProductName, "RecentExecutedCommand", command);
+                mp.command_string(command, false);
+            }));
+        }
+        
+        public static void open_url(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                string command = Microsoft.VisualBasic.Interaction.InputBox("Enter URL to be opened.");
+                if (string.IsNullOrEmpty(command)) return;
+                mp.LoadFiles(command);
+            }));
+        }
+
+        public static void load_sub(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                using (var d = new OpenFileDialog())
+                {
+                    d.InitialDirectory = Path.GetDirectoryName(mp.get_property_string("path", false));
+                    d.Multiselect = true;
+
+                    if (d.ShowDialog() == DialogResult.OK)
+                        foreach (string i in d.FileNames)
+                            mp.commandv("sub-add", i);
+                }
+            }));
+        }
+
+        public static void load_audio(string[] args)
+        {
+            MainForm.Instance.Invoke(new Action(() => {
+                using (var d = new OpenFileDialog())
+                {
+                    d.InitialDirectory = Path.GetDirectoryName(mp.get_property_string("path", false));
+                    d.Multiselect = true;
+
+                    if (d.ShowDialog() == DialogResult.OK)
+                        foreach (string i in d.FileNames)
+                            mp.commandv("audio-add", i);
+                }
+            }));
+        }
+
+        public static void cycle_audio(string[] args)
+        {
+            string filePath = mp.get_property_string("path", false);
+            if (!File.Exists(filePath)) return;
+
+            using (MediaInfo mi = new MediaInfo(filePath))
+            {
+                MediaTrack[] audTracks = mp.MediaTracks.Where(track => track.Type == "a").ToArray();
+                if (audTracks.Length < 2) return;
+                int aid = mp.get_property_int("aid");
+                aid += 1;
+                if (aid > audTracks.Length) aid = 1;
+                mp.commandv("set", "aid", aid.ToString());
+                mp.commandv("show-text", audTracks[aid - 1].Text.Substring(3), "5000");
+            }
+        }
+
+        public static void manage_file_associations(string[] args)
+        {
+            using (var td = new TaskDialog<string>())
+            {
+                td.MainInstruction = "Choose an option.";
+                td.MainIcon = MsgIcon.Shield;
+
+                td.AddCommandLink("Register video file extensions", "video");
+                td.AddCommandLink("Register audio file extensions", "audio");
+                td.AddCommandLink("Unregister file extensions",     "unreg");
+
+                string result = td.Show();
+
+                if (!string.IsNullOrEmpty(result))
+                {
+                    using (var proc = new Process())
+                    {
+                        proc.StartInfo.FileName = Application.ExecutablePath;
+                        proc.StartInfo.Arguments = "--reg-file-assoc " + result;
+                        proc.StartInfo.Verb = "runas";
+                        try {
+                            proc.Start();
+                        }
+                        catch (Exception)
+                        { }
+                    }
+                }
+            }
+        }
+    }
+}

mpv.net/Misc/Misc.cs

@@ -0,0 +1,296 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using System.ComponentModel;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Runtime.Serialization;
+using System.Windows.Forms;
+
+using Microsoft.Win32;
+
+namespace mpvnet
+{
+    public class App
+    {
+        public static string[] VideoTypes { get; } = "mkv mp4 mpg avi mov webm vob wmv flv avs 264 h264 asf webm mpeg mpv y4m avc hevc 265 h265 m2v m2ts vpy mts m4v".Split(" ".ToCharArray());
+        public static string[] AudioTypes { get; } = "mp3 mp2 ac3 ogg opus flac wav w64 m4a dts dtsma dtshr dtshd eac3 thd thd+ac3 mka aac mpa".Split(" ".ToCharArray());
+
+        public static bool IsDarkMode { 
+            get {
+                string darkMode = MainForm.Instance.MpvNetDarkMode;
+                return (darkMode == "system" && Sys.IsDarkTheme) || darkMode == "always";
+            }
+        }
+    }
+
+    public class Sys
+    {
+        public static bool IsDarkTheme {
+            get {
+                object value = Registry.GetValue(@"HKEY_CURRENT_USER\Software\Microsoft\Windows\CurrentVersion\Themes\Personalize", "AppsUseLightTheme", 1);
+                if (value is null) value = 1;
+                return (int)value == 0;
+            }
+        }
+
+        public static bool IsDirectoryWritable(string dirPath)
+        {
+            try
+            {
+                using (FileStream fs = File.Create(Path.Combine(dirPath,
+                    Path.GetRandomFileName()), 1, FileOptions.DeleteOnClose))
+                { }
+                return true;
+            }
+            catch
+            { }
+            return false;
+        }
+    }
+
+    public class StringLogicalComparer : IComparer, IComparer<string>
+    {
+        [DllImport("shlwapi.dll", CharSet = CharSet.Unicode)]
+        public static extern int StrCmpLogical(string x, string y);
+
+        int IComparer_Compare(object x, object y) => StrCmpLogical(x.ToString(), y.ToString());
+        int IComparer.Compare(object x, object y) => IComparer_Compare(x, y);
+        int IComparerOfString_Compare(string x, string y) => StrCmpLogical(x, y);
+        int IComparer<string>.Compare(string x, string y) => IComparerOfString_Compare(x, y);
+    }
+
+    public class FileAssociation
+    {
+        static string ExePath = Application.ExecutablePath;
+        static string ExeFilename = Path.GetFileName(Application.ExecutablePath);
+        static string ExeFilenameNoExt = Path.GetFileNameWithoutExtension(Application.ExecutablePath);
+        static string[] Types;
+
+        public static void Register(string[] types)
+        {
+            Types = types;
+
+            RegistryHelp.SetObject(@"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\" + ExeFilename, null, ExePath);
+            RegistryHelp.SetObject($"HKCR\\Applications\\{ExeFilename}", "FriendlyAppName", "mpv.net media player");
+            RegistryHelp.SetObject($"HKCR\\Applications\\{ExeFilename}\\shell\\open\\command", null, $"\"{ExePath}\" \"%1\"");
+            RegistryHelp.SetObject(@"HKLM\SOFTWARE\Clients\Media\mpv\Capabilities", "ApplicationDescription", "mpv.net media player");
+            RegistryHelp.SetObject(@"HKLM\SOFTWARE\Clients\Media\mpv\Capabilities", "ApplicationName", "mpv.net");
+            RegistryHelp.SetObject($"HKCR\\SystemFileAssociations\\video\\OpenWithList\\{ExeFilename}", null, "");
+            RegistryHelp.SetObject($"HKCR\\SystemFileAssociations\\audio\\OpenWithList\\{ExeFilename}", null, "");
+
+            foreach (string ext in Types)
+            {
+                RegistryHelp.SetObject($"HKCR\\Applications\\{ExeFilename}\\SupportedTypes", "." + ext, "");
+                RegistryHelp.SetObject($"HKCR\\" + "." + ext, null, ExeFilenameNoExt + "." + ext);
+                RegistryHelp.SetObject($"HKCR\\" + "." + ext + "\\OpenWithProgIDs", ExeFilenameNoExt + "." + ext, "");
+                if (App.VideoTypes.Contains(ext))
+                    RegistryHelp.SetObject($"HKCR\\" + "." + ext, "PerceivedType", "video");
+                if (App.AudioTypes.Contains(ext))
+                    RegistryHelp.SetObject($"HKCR\\" + "." + ext, "PerceivedType", "audio");
+                RegistryHelp.SetObject($"HKCR\\" + ExeFilenameNoExt + "." + ext + "\\shell\\open", null, "Play with " +  Application.ProductName);
+                RegistryHelp.SetObject($"HKCR\\" + ExeFilenameNoExt + "." + ext + "\\shell\\open\\command", null, $"\"{ExePath}\" \"%1\"");
+                RegistryHelp.SetObject(@"HKLM\SOFTWARE\Clients\Media\mpv.net\Capabilities\FileAssociations", "." + ext, ExeFilenameNoExt + "." + ext);
+            }
+        }
+
+        public static void Unregister()
+        {
+            RegistryHelp.RemoveKey(@"HKCU\SOFTWARE\Microsoft\Windows\CurrentVersion\App Paths\" + ExeFilename);
+            RegistryHelp.RemoveKey($"HKCR\\Applications\\{ExeFilename}");
+            RegistryHelp.RemoveKey(@"HKLM\SOFTWARE\Clients\Media\mpv.net");
+            RegistryHelp.RemoveKey($"HKCR\\SystemFileAssociations\\video\\OpenWithList\\{ExeFilename}");
+            RegistryHelp.RemoveKey($"HKCR\\SystemFileAssociations\\audio\\OpenWithList\\{ExeFilename}");
+
+            foreach (string id in Registry.ClassesRoot.GetSubKeyNames())
+            {
+                if (id.StartsWith(ExeFilenameNoExt + "."))
+                    Registry.ClassesRoot.DeleteSubKeyTree(id);
+
+                RegistryHelp.RemoveValue($"HKCR\\Software\\Classes\\" + id + "\\OpenWithProgIDs", ExeFilenameNoExt + id);
+                RegistryHelp.RemoveValue($"HKLM\\Software\\Classes\\" + id + "\\OpenWithProgIDs", ExeFilenameNoExt + id);
+            }
+        }
+    }
+
+    public class RegistryHelp
+    {
+        public static void SetObject(string path, string name, object value)
+        {
+            using (RegistryKey rk = GetRootKey(path).CreateSubKey(path.Substring(5), RegistryKeyPermissionCheck.ReadWriteSubTree))
+                rk.SetValue(name, value);
+        }
+
+        public static string GetString(string path, string name)
+        {
+            object val = GetObject(path, name);
+            if (val == null || !(val is string)) return "";
+            return val.ToString();
+        }
+
+        public static object GetObject(string path, string name)
+        {
+            using (RegistryKey rk = GetRootKey(path).OpenSubKey(path.Substring(5)))
+                if (rk != null)
+                    return rk.GetValue(name, "");
+                else
+                    return null;
+        }
+
+        public static void RemoveKey(string path)
+        {
+            GetRootKey(path).DeleteSubKeyTree(path.Substring(5), false);
+        }
+
+        public static void RemoveValue(string path, string name)
+        {
+            using (RegistryKey rk = GetRootKey(path).OpenSubKey(path.Substring(5), true))
+                if (!(rk is null))
+                    rk.DeleteValue(name, false);
+        }
+
+        static RegistryKey GetRootKey(string path)
+        {
+            switch (path.Substring(0, 4))
+            {
+                case "HKLM": return Registry.LocalMachine;
+                case "HKCU": return Registry.CurrentUser;
+                case "HKCR": return Registry.ClassesRoot;
+                default: throw new Exception();
+            }
+        }
+    }
+
+    public class MediaTrack
+    {
+        public string Text { get; set; }
+        public string Type { get; set; }
+        public int    ID   { get; set; }
+    }
+
+    public class CommandItem : INotifyPropertyChanged
+    {
+        public event PropertyChangedEventHandler PropertyChanged;
+
+        public string Path { get; set; } = "";
+        public string Command { get; set; } = "";
+
+        public CommandItem() { }
+
+        public CommandItem(SerializationInfo info, StreamingContext context) { }
+
+        private void NotifyPropertyChanged([CallerMemberName] string propertyName = "")
+        {
+            PropertyChanged?.Invoke(this, new PropertyChangedEventArgs(propertyName));
+        }
+
+        private string _Input = "";
+
+        public string Input {
+            get => _Input;
+            set {
+                _Input = value;
+                NotifyPropertyChanged();
+            }
+        }
+
+        public static ObservableCollection<CommandItem> GetItems(string content)
+        {
+            var items = new ObservableCollection<CommandItem>();
+
+            if (!string.IsNullOrEmpty(content))
+            {
+                foreach (string line in content.Split('\r', '\n'))
+                {
+                    string val = line.Trim();
+                    if (val.StartsWith("#")) continue;
+                    if (!val.Contains(" ")) continue;
+                    CommandItem item = new CommandItem();
+                    item.Input = val.Substring(0, val.IndexOf(" "));
+                    if (item.Input == "_") item.Input = "";
+                    val = val.Substring(val.IndexOf(" ") + 1);
+
+                    if (val.Contains("#menu:"))
+                    {
+                        item.Path = val.Substring(val.IndexOf("#menu:") + 6).Trim();
+                        val = val.Substring(0, val.IndexOf("#menu:"));
+                        if (item.Path.Contains(";"))
+                            item.Path = item.Path.Substring(item.Path.IndexOf(";") + 1).Trim();
+                    }
+
+                    item.Command = val.Trim();
+                    if (item.Command == "")
+                        continue;
+                    if (item.Command.ToLower() == "ignore")
+                        item.Command = "";
+                    MigrateCommands(item);
+                    items.Add(item);
+                }
+            }
+            return items;
+        }
+
+        private static ObservableCollection<CommandItem> _Items;
+
+        public static ObservableCollection<CommandItem> Items {
+            get {
+                if (_Items is null)
+                    _Items = GetItems(File.ReadAllText(mp.InputConfPath));
+                return _Items;
+            }
+        }
+
+        public static void MigrateCommands(CommandItem item)
+        {
+            switch (item.Command)
+            {
+                case "script-message mpv.net show-prefs":
+                    item.Command = "script-message mpv.net show-conf-editor";
+                    break;
+                case "script-message mpv.net show-keys":
+                    item.Command = "script-message mpv.net show-input-editor";
+                    break;
+                case "script-message mpv.net history":
+                    item.Command = "script-message mpv.net show-history";
+                    break;
+                case "script-message mpv.net open-config-folder":
+                    item.Command = "script-message open-conf-folder";
+                    break;
+            }
+        }
+    }
+
+    public class CursorHelp
+    {
+        static bool IsVisible = true;
+
+        public static void Show()
+        {
+            if (!IsVisible)
+            {
+                Cursor.Show();
+                IsVisible = true;
+            }
+        }
+
+        public static void Hide()
+        {
+            if (IsVisible)
+            {
+                Cursor.Hide();
+                IsVisible = false;
+            }
+        }
+
+        public static bool IsPosDifferent(Point screenPos)
+        {
+            return
+                Math.Abs(screenPos.X - Control.MousePosition.X) > 10 ||
+                Math.Abs(screenPos.Y - Control.MousePosition.Y) > 10;
+        }
+    }
+}

mpv.net/Misc/Program.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Windows.Forms;
+
+namespace mpvnet
+{
+    static class Program
+    {
+        [STAThread]
+        static void Main()
+        {
+            try
+            {
+                string[] args = Environment.GetCommandLineArgs();
+
+                if (args.Length == 3 && args[1] == "--reg-file-assoc")
+                {
+                    if (args[2] == "audio") FileAssociation.Register(App.AudioTypes);
+                    if (args[2] == "video") FileAssociation.Register(App.VideoTypes);
+                    if (args[2] == "unreg") FileAssociation.Unregister();
+                    return;
+                }
+
+                Application.EnableVisualStyles();
+                Application.SetCompatibleTextRenderingDefault(false);
+                Application.Run(new MainForm());
+            }
+            catch (Exception ex)
+            {
+                Msg.ShowException(ex);
+            }
+        }
+    }
+}