From 714ead809c0d20f7589b65bf3e26f0be0f395ee1 Mon Sep 17 00:00:00 2001 From: Tichau Date: Mon, 6 Apr 2015 12:50:22 +0200 Subject: [PATCH] Initial project commit --- Application/FileConverter/App.config | 6 + Application/FileConverter/Application.xaml | 8 + Application/FileConverter/Application.xaml.cs | 188 + Application/FileConverter/ConversionJob.cs | 257 + .../FileConverter/ConversionStateToBrush.cs | 75 + Application/FileConverter/Diagnostics.cs | 41 + .../FileConverter/FileConverter.csproj | 119 + Application/FileConverter/FileConverter.sln | 54 + .../FileConverter.sln.DotSettings | 8 + Application/FileConverter/MainWindow.xaml | 78 + Application/FileConverter/MainWindow.xaml.cs | 51 + Application/FileConverter/OutputType.cs | 12 + .../FileConverter/Properties/Annotations.cs | 664 + .../FileConverter/Properties/AssemblyInfo.cs | 55 + .../Properties/Resources.Designer.cs | 71 + .../FileConverter/Properties/Resources.resx | 117 + .../Properties/Settings.Designer.cs | 30 + .../Properties/Settings.settings | 7 + Application/FileConverter/ReadMe.txt | 5 + Application/FileConverter/Settings.StyleCop | 24 + .../FileConverterExtension.cs | 140 + .../FileConverterExtension.csproj | 68 + .../FileConverterExtensionKey.snk | Bin 0 -> 596 bytes .../FileConverterExtension/FileType.cs | 13 + .../Properties/AssemblyInfo.cs | 36 + Installer/Extension.wxs | 23 + Installer/GenerateExtensionWxsFile.bat | 1 + Installer/Installer.wixproj | 52 + Installer/Product.wxs | 56 + .../ServerManager/Apex.WinForms.dll | Bin 0 -> 34304 bytes .../ServerManager/ServerManager.exe | Bin 0 -> 172032 bytes .../SharpShell/ServerManager/SharpShell.dll | Bin 0 -> 384512 bytes .../SharpShell/ServerManager/SharpShell.zip | Bin 0 -> 310648 bytes Middleware/SharpShell/ServerManager/srm.zip | Bin 0 -> 142983 bytes Middleware/SharpShell/SharpShell.dll | Bin 0 -> 384512 bytes Middleware/SharpShell/SharpShell.xml | 10224 ++++++++++++++++ Middleware/ffmpeg.exe | Bin 0 -> 25873920 bytes 37 files changed, 12483 insertions(+) create mode 100644 Application/FileConverter/App.config create mode 100644 Application/FileConverter/Application.xaml create mode 100644 Application/FileConverter/Application.xaml.cs create mode 100644 Application/FileConverter/ConversionJob.cs create mode 100644 Application/FileConverter/ConversionStateToBrush.cs create mode 100644 Application/FileConverter/Diagnostics.cs create mode 100644 Application/FileConverter/FileConverter.csproj create mode 100644 Application/FileConverter/FileConverter.sln create mode 100644 Application/FileConverter/FileConverter.sln.DotSettings create mode 100644 Application/FileConverter/MainWindow.xaml create mode 100644 Application/FileConverter/MainWindow.xaml.cs create mode 100644 Application/FileConverter/OutputType.cs create mode 100644 Application/FileConverter/Properties/Annotations.cs create mode 100644 Application/FileConverter/Properties/AssemblyInfo.cs create mode 100644 Application/FileConverter/Properties/Resources.Designer.cs create mode 100644 Application/FileConverter/Properties/Resources.resx create mode 100644 Application/FileConverter/Properties/Settings.Designer.cs create mode 100644 Application/FileConverter/Properties/Settings.settings create mode 100644 Application/FileConverter/ReadMe.txt create mode 100644 Application/FileConverter/Settings.StyleCop create mode 100644 Application/FileConverterExtension/FileConverterExtension.cs create mode 100644 Application/FileConverterExtension/FileConverterExtension.csproj create mode 100644 Application/FileConverterExtension/FileConverterExtensionKey.snk create mode 100644 Application/FileConverterExtension/FileType.cs create mode 100644 Application/FileConverterExtension/Properties/AssemblyInfo.cs create mode 100644 Installer/Extension.wxs create mode 100644 Installer/GenerateExtensionWxsFile.bat create mode 100644 Installer/Installer.wixproj create mode 100644 Installer/Product.wxs create mode 100644 Middleware/SharpShell/ServerManager/Apex.WinForms.dll create mode 100644 Middleware/SharpShell/ServerManager/ServerManager.exe create mode 100644 Middleware/SharpShell/ServerManager/SharpShell.dll create mode 100644 Middleware/SharpShell/ServerManager/SharpShell.zip create mode 100644 Middleware/SharpShell/ServerManager/srm.zip create mode 100644 Middleware/SharpShell/SharpShell.dll create mode 100644 Middleware/SharpShell/SharpShell.xml create mode 100644 Middleware/ffmpeg.exe diff --git a/Application/FileConverter/App.config b/Application/FileConverter/App.config new file mode 100644 index 0000000..8e15646 --- /dev/null +++ b/Application/FileConverter/App.config @@ -0,0 +1,6 @@ + + + + + + \ No newline at end of file diff --git a/Application/FileConverter/Application.xaml b/Application/FileConverter/Application.xaml new file mode 100644 index 0000000..dc72190 --- /dev/null +++ b/Application/FileConverter/Application.xaml @@ -0,0 +1,8 @@ + + + + + diff --git a/Application/FileConverter/Application.xaml.cs b/Application/FileConverter/Application.xaml.cs new file mode 100644 index 0000000..81d86c4 --- /dev/null +++ b/Application/FileConverter/Application.xaml.cs @@ -0,0 +1,188 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + using System; + using System.Collections.Generic; + using System.Collections.ObjectModel; + using System.Threading; + + public partial class Application : System.Windows.Application + { + private readonly List conversionJobs = new List(); + + private bool debugMode; + private bool initialized; + + public Application() + { + this.Initialize(); + + if (this.initialized) + { + Thread fileConvertionThread = new Thread(this.ConvertFiles); + fileConvertionThread.Start(); + } + } + + public ReadOnlyCollection ConvertionJobs + { + get; + private set; + } + + public bool Verbose + { + get; + set; + } + + private void Initialize() + { + this.ConvertionJobs = this.conversionJobs.AsReadOnly(); + + Diagnostics.Log("Retrieve arguments..."); + string[] args = Environment.GetCommandLineArgs(); + + if (args.Length <= 1) + { + this.debugMode = true; + System.Array.Resize(ref args, 9); + args[1] = "--output-type"; + args[2] = "mp3"; + args[3] = @"D:\Projects\FileConverter\TestFiles\Herbie Hancock - Speak Like A Child [RVG Edition].flac"; + args[4] = @"D:\Projects\FileConverter\TestFiles\test\Toccata.wav"; + args[5] = @"D:\Projects\FileConverter\TestFiles\test\Toccata - Copie (4).wav"; + //// args[5] = "--verbose"; + args[6] = @"D:\Projects\FileConverter\TestFiles\test\Toccata - Copie (3).wav"; + args[7] = @"D:\Projects\FileConverter\TestFiles\test\Toccata - Copie (2).wav"; + args[8] = @"D:\Projects\FileConverter\TestFiles\test\Toccata - Copie (5).wav"; + } + + for (int index = 0; index < args.Length; index++) + { + string argument = args[index]; + Diagnostics.Log("Arg{0}: {1}", index, argument); + } + + Diagnostics.Log(string.Empty); + + OutputType outputType = OutputType.None; + List filePaths = new List(); + for (int index = 1; index < args.Length; index++) + { + string argument = args[index]; + if (argument.StartsWith("--")) + { + // This is an optional parameter. + string parameterTitle = argument.Substring(2).ToLowerInvariant(); + + switch (parameterTitle) + { + case "output-type": + { + if (index >= args.Length - 1) + { + Diagnostics.Log("ERROR ! Invalid format."); + return; + } + + string outputTypeName = args[index + 1].ToLowerInvariant(); + switch (outputTypeName) + { + case "mp3": + outputType = OutputType.Mp3; + break; + + case "ogg": + outputType = OutputType.Ogg; + break; + + case "flac": + outputType = OutputType.Flac; + break; + + default: + Diagnostics.Log("ERROR ! Unknown output type {0}.", outputType); + return; + } + + index++; + continue; + } + + case "verbose": + { + this.Verbose = true; + } + + break; + + default: + Diagnostics.Log("ERROR ! Unknown option {0}.", parameterTitle); + return; + } + } + else + { + filePaths.Add(argument); + } + } + + if (outputType == OutputType.None) + { + Diagnostics.Log("ERROR ! Can't retrieve the output type from arguments."); + return; + } + + // Create convertion jobs. + for (int index = 0; index < filePaths.Count; index++) + { + ConversionJob conversionJob = new ConversionJob(); + + string inputFilePath = filePaths[index]; + string extension = System.IO.Path.GetExtension(inputFilePath); + string outputFilePath = inputFilePath.Substring(0, inputFilePath.Length - extension.Length) + "." + + outputType.ToString().ToLowerInvariant(); + + conversionJob.Initialize(outputType, inputFilePath, outputFilePath); + + this.conversionJobs.Add(conversionJob); + } + + this.initialized = true; + } + + private void ConvertFiles() + { + for (int index = 0; index < this.conversionJobs.Count; index++) + { + ConversionJob conversionJob = this.conversionJobs[index]; + conversionJob.StartConvertion(); + + if (System.IO.File.Exists(conversionJob.OutputFilePath)) + { + Diagnostics.Log("Success!"); + + if (this.debugMode) + { + Diagnostics.Log("Delete file {0}.", conversionJob.OutputFilePath); + try + { + System.IO.File.Delete(conversionJob.OutputFilePath); + } + catch + { + } + } + } + else + { + Diagnostics.Log("Fail!"); + } + } + + Diagnostics.Log("End of job queue."); + } + } +} diff --git a/Application/FileConverter/ConversionJob.cs b/Application/FileConverter/ConversionJob.cs new file mode 100644 index 0000000..a20ae0f --- /dev/null +++ b/Application/FileConverter/ConversionJob.cs @@ -0,0 +1,257 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + using System; + using System.ComponentModel; + using System.Diagnostics; + using System.IO; + using System.Runtime.CompilerServices; + using System.Text.RegularExpressions; + + public class ConversionJob : INotifyPropertyChanged + { + private readonly Regex durationRegex = new Regex(@"Duration: ([0-9][0-9]):([0-9][0-9]):([0-9][0-9])\.([0-9][0-9]), bitrate: ([0-9]+) kb\/s"); + private readonly Regex progressRegex = new Regex(@"size=[ ]*([0-9]+)kB time=([0-9][0-9]):([0-9][0-9]):([0-9][0-9]).([0-9][0-9]) bitrate= ([0-9]+.[0-9])kbits\/s"); + + private TimeSpan fileDuration; + private TimeSpan actualConvertedDuration; + + private ProcessStartInfo ffmpegProcessStartInfo; + + private float progress; + + private ConversionState state; + + private string exitingMessage; + + public ConversionJob() + { + this.OutputType = OutputType.None; + this.progress = 0f; + this.InputFilePath = string.Empty; + this.OutputFilePath = string.Empty; + this.State = ConversionState.Unknown; + this.ExitingMessage = string.Empty; + } + + public event PropertyChangedEventHandler PropertyChanged; + + public enum ConversionState + { + Unknown, + + Ready, + InProgress, + Done, + Failed, + } + + public string InputFilePath + { + get; + private set; + } + + public string OutputFilePath + { + get; + private set; + } + + public OutputType OutputType + { + get; + private set; + } + + public ConversionState State + { + get + { + return this.state; + } + + private set + { + this.state = value; + this.NotifyPropertyChanged(); + } + } + + public float Progress + { + get + { + return this.progress; + } + + private set + { + this.progress = value; + this.NotifyPropertyChanged(); + } + } + + public string ExitingMessage + { + get + { + return this.exitingMessage; + } + + set + { + this.exitingMessage = value; + this.NotifyPropertyChanged(); + } + } + + public void Initialize(OutputType outputType, string inputFileName, string outputFileName) + { + if (outputType == OutputType.None) + { + throw new ArgumentException("The output type must be valid.", "outputType"); + } + + this.OutputType = outputType; + this.ffmpegProcessStartInfo = null; + + string applicationDirectory = System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location); + string ffmpegPath = string.Format("{0}\\ffmpeg.exe", applicationDirectory); + if (!System.IO.File.Exists(ffmpegPath)) + { + Diagnostics.Log("Can't find ffmpeg executable ({0}). Try to reinstall the application.", ffmpegPath); + return; + } + + this.ffmpegProcessStartInfo = new ProcessStartInfo(ffmpegPath); + + this.ffmpegProcessStartInfo.CreateNoWindow = true; + this.ffmpegProcessStartInfo.UseShellExecute = false; + this.ffmpegProcessStartInfo.RedirectStandardOutput = true; + this.ffmpegProcessStartInfo.RedirectStandardError = true; + + this.InputFilePath = inputFileName; + this.OutputFilePath = outputFileName; + + this.State = ConversionState.Ready; + } + + public void StartConvertion() + { + if (this.OutputType == OutputType.None) + { + throw new Exception("The converter is not initialized."); + } + + Diagnostics.Log("Convert file {0} to {1}.", this.InputFilePath, this.OutputFilePath); + + string arguments = string.Empty; + switch (this.OutputType) + { + case OutputType.Mp3: + arguments = string.Format("-n -i \"{0}\" -stats -ar 44100 -ab 320k -map_metadata 0:s:0 -id3v2_version 3 -write_id3v1 1 \"{1}\"", this.InputFilePath, this.OutputFilePath); + break; + + case OutputType.Ogg: + arguments = string.Format("-n -i \"{0}\" -map_metadata 0:s:0 \"{1}\"", this.InputFilePath, this.OutputFilePath); + break; + + case OutputType.Flac: + arguments = string.Format("-n -i \"{0}\" -map_metadata 0:s:0 \"{1}\"", this.InputFilePath, this.OutputFilePath); + break; + } + + if (string.IsNullOrEmpty(arguments) || this.ffmpegProcessStartInfo == null) + { + return; + } + + this.State = ConversionState.InProgress; + + try + { + Diagnostics.Log(string.Empty); + this.ffmpegProcessStartInfo.Arguments = arguments; + Diagnostics.Log("Execute command: {0} {1}.", this.ffmpegProcessStartInfo.FileName, this.ffmpegProcessStartInfo.Arguments); + using (Process exeProcess = Process.Start(this.ffmpegProcessStartInfo)) + { + using (StreamReader reader = exeProcess.StandardError) + { + while (!reader.EndOfStream) + { + string result = reader.ReadLine(); + + this.ParseFFMPEGOutput(result); + + Diagnostics.Log("ffmpeg output: {0}", result); + } + } + + exeProcess.WaitForExit(); + } + } + catch + { + this.State = ConversionState.Failed; + throw; + } + + if (this.progress < 1f) + { + this.State = ConversionState.Failed; + return; + } + + this.State = ConversionState.Done; + + Diagnostics.Log("\nDone!"); + } + + private void ParseFFMPEGOutput(string input) + { + Match match = this.durationRegex.Match(input); + if (match.Success && match.Groups.Count >= 6) + { + int hours = int.Parse(match.Groups[1].Value); + int minutes = int.Parse(match.Groups[2].Value); + int seconds = int.Parse(match.Groups[3].Value); + int milliseconds = int.Parse(match.Groups[4].Value); + float bitrate = float.Parse(match.Groups[5].Value); + this.fileDuration = new TimeSpan(0, hours, minutes, seconds, milliseconds); + return; + } + + match = this.progressRegex.Match(input); + if (match.Success && match.Groups.Count >= 7) + { + int size = int.Parse(match.Groups[1].Value); + int hours = int.Parse(match.Groups[2].Value); + int minutes = int.Parse(match.Groups[3].Value); + int seconds = int.Parse(match.Groups[4].Value); + int milliseconds = int.Parse(match.Groups[5].Value); + float bitrate = 0f; + float.TryParse(match.Groups[6].Value, out bitrate); + + this.actualConvertedDuration = new TimeSpan(0, hours, minutes, seconds, milliseconds); + + this.Progress = this.actualConvertedDuration.Ticks / (float)this.fileDuration.Ticks; + return; + } + + if (input.Contains("Exiting.")) + { + this.ExitingMessage = input; + } + } + + private void NotifyPropertyChanged([CallerMemberName] string propertyName = "") + { + if (this.PropertyChanged != null) + { + this.PropertyChanged(this, new PropertyChangedEventArgs(propertyName)); + } + } + } +} diff --git a/Application/FileConverter/ConversionStateToBrush.cs b/Application/FileConverter/ConversionStateToBrush.cs new file mode 100644 index 0000000..ff7860f --- /dev/null +++ b/Application/FileConverter/ConversionStateToBrush.cs @@ -0,0 +1,75 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + using System; + using System.Globalization; + using System.Windows.Data; + using System.Windows.Media; + + public class ConversionStateToBrush : IValueConverter + { + public object Convert(object value, Type targetType, object parameter, CultureInfo culture) + { + if (!(value is ConversionJob.ConversionState)) + { + throw new ArgumentException("The value must be a conversion state."); + } + + ConversionJob.ConversionState conversionState = (ConversionJob.ConversionState)value; + string type = parameter as string; + + if (type == "Background") + { + switch (conversionState) + { + case ConversionJob.ConversionState.Unknown: + return new SolidColorBrush(Color.FromRgb(230, 230, 230)); + + case ConversionJob.ConversionState.Ready: + return new SolidColorBrush(Color.FromRgb(230, 230, 230)); + + case ConversionJob.ConversionState.InProgress: + return new SolidColorBrush(Color.FromRgb(250, 236, 179)); + + case ConversionJob.ConversionState.Done: + return new SolidColorBrush(Color.FromRgb(200, 230, 201)); + + case ConversionJob.ConversionState.Failed: + return new SolidColorBrush(Color.FromRgb(255, 205, 210)); + } + } + else if (type == "Foreground") + { + switch (conversionState) + { + case ConversionJob.ConversionState.Unknown: + return new SolidColorBrush(Color.FromRgb(128, 128, 128)); + + case ConversionJob.ConversionState.Ready: + return new SolidColorBrush(Color.FromRgb(32, 32, 32)); + + case ConversionJob.ConversionState.InProgress: + return new SolidColorBrush(Color.FromRgb(255, 160, 0)); + + case ConversionJob.ConversionState.Done: + return new SolidColorBrush(Color.FromRgb(56, 142, 60)); + + case ConversionJob.ConversionState.Failed: + return new SolidColorBrush(Color.FromRgb(255, 82, 82)); + } + } + else + { + throw new SystemException("Unknown type."); + } + + throw new SystemException("Unknown state."); + } + + public object ConvertBack(object value, Type targetType, object parameter, CultureInfo culture) + { + throw new NotImplementedException(); + } + } +} diff --git a/Application/FileConverter/Diagnostics.cs b/Application/FileConverter/Diagnostics.cs new file mode 100644 index 0000000..a500c6c --- /dev/null +++ b/Application/FileConverter/Diagnostics.cs @@ -0,0 +1,41 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + using System; + using System.Collections.Generic; + using System.ComponentModel; + using System.Text; + + public static class Diagnostics + { + private static List logMessages = new List(); + private static StringBuilder workingStringBuilder = new StringBuilder(); + + public static event EventHandler StaticPropertyChanged; + + public static string Content + { + get + { + workingStringBuilder.Clear(); + for (int index = 0; index < logMessages.Count; index++) + { + workingStringBuilder.AppendLine(logMessages[index]); + } + + return workingStringBuilder.ToString(); + } + } + + public static void Log(string message, params object[] arguments) + { + Diagnostics.logMessages.Add(string.Format(message, arguments)); + + if (StaticPropertyChanged != null) + { + StaticPropertyChanged(null, new PropertyChangedEventArgs("Content")); + } + } + } +} diff --git a/Application/FileConverter/FileConverter.csproj b/Application/FileConverter/FileConverter.csproj new file mode 100644 index 0000000..f42db46 --- /dev/null +++ b/Application/FileConverter/FileConverter.csproj @@ -0,0 +1,119 @@ + + + + + Debug + AnyCPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5} + WinExe + Properties + FileConverter + FileConverter + v4.5 + 512 + {60dc8134-eba5-43b8-bcc9-bb4bc16c2548};{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC} + 4 + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + AnyCPU + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + + + + + + + + + + + + + + 4.0 + + + + + + + + + + MSBuild:Compile + Designer + + + MSBuild:Compile + Designer + + + Application.xaml + Code + + + + + + MainWindow.xaml + Code + + + + + + + Code + + + True + True + Resources.resx + + + True + Settings.settings + True + + + ResXFileCodeGenerator + Resources.Designer.cs + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + + + + + + + + + + \ No newline at end of file diff --git a/Application/FileConverter/FileConverter.sln b/Application/FileConverter/FileConverter.sln new file mode 100644 index 0000000..87ae28b --- /dev/null +++ b/Application/FileConverter/FileConverter.sln @@ -0,0 +1,54 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio 2012 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FileConverter", "FileConverter.csproj", "{D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}" +EndProject +Project("{930C7802-8A8C-48F9-8165-68863BCCD9DD}") = "Installer", "..\..\Installer\Installer.wixproj", "{F14673DF-DF38-44B4-AB1D-99A59182C24C}" +EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "FileConverterExtension", "..\FileConverterExtension\FileConverterExtension.csproj", "{0C44CA69-42D6-4357-BDFD-83069D1ABA2F}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|Mixed Platforms = Debug|Mixed Platforms + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|Mixed Platforms = Release|Mixed Platforms + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Debug|Any CPU.Build.0 = Debug|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Debug|x86.ActiveCfg = Debug|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Release|Any CPU.ActiveCfg = Release|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Release|Any CPU.Build.0 = Release|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {D27A76D2-43E4-43CC-9DA3-334B0B46F4E5}.Release|x86.ActiveCfg = Release|Any CPU + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Debug|Any CPU.ActiveCfg = Debug|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Debug|Mixed Platforms.ActiveCfg = Debug|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Debug|Mixed Platforms.Build.0 = Debug|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Debug|x86.ActiveCfg = Debug|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Debug|x86.Build.0 = Debug|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Release|Any CPU.ActiveCfg = Release|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Release|Mixed Platforms.ActiveCfg = Release|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Release|Mixed Platforms.Build.0 = Release|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Release|x86.ActiveCfg = Release|x86 + {F14673DF-DF38-44B4-AB1D-99A59182C24C}.Release|x86.Build.0 = Release|x86 + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Debug|Any CPU.Build.0 = Debug|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Debug|Mixed Platforms.ActiveCfg = Debug|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Debug|Mixed Platforms.Build.0 = Debug|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Debug|x86.ActiveCfg = Debug|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Release|Any CPU.ActiveCfg = Release|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Release|Any CPU.Build.0 = Release|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Release|Mixed Platforms.ActiveCfg = Release|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Release|Mixed Platforms.Build.0 = Release|Any CPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F}.Release|x86.ActiveCfg = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection +EndGlobal diff --git a/Application/FileConverter/FileConverter.sln.DotSettings b/Application/FileConverter/FileConverter.sln.DotSettings new file mode 100644 index 0000000..0599cda --- /dev/null +++ b/Application/FileConverter/FileConverter.sln.DotSettings @@ -0,0 +1,8 @@ + + True + HINT + DO_NOT_SHOW + DO_NOT_SHOW + DO_NOT_SHOW + False + False \ No newline at end of file diff --git a/Application/FileConverter/MainWindow.xaml b/Application/FileConverter/MainWindow.xaml new file mode 100644 index 0000000..0a3508f --- /dev/null +++ b/Application/FileConverter/MainWindow.xaml @@ -0,0 +1,78 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/Application/FileConverter/MainWindow.xaml.cs b/Application/FileConverter/MainWindow.xaml.cs new file mode 100644 index 0000000..a52356e --- /dev/null +++ b/Application/FileConverter/MainWindow.xaml.cs @@ -0,0 +1,51 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + using System.ComponentModel; + using System.Runtime.CompilerServices; + using System.Windows; + + using FileConverter.Annotations; + + public partial class MainWindow : Window, INotifyPropertyChanged + { + private bool verboseMode; + + public MainWindow() + { + this.InitializeComponent(); + + Application application = Application.Current as Application; + + this.ConverterJobsList.ItemsSource = application.ConvertionJobs; + this.VerboseMode = application.Verbose; + } + + public event PropertyChangedEventHandler PropertyChanged; + + public bool VerboseMode + { + get + { + return this.verboseMode; + } + + set + { + this.verboseMode = value; + this.OnPropertyChanged(); + } + } + + [NotifyPropertyChangedInvocator] + protected virtual void OnPropertyChanged([CallerMemberName] string propertyName = null) + { + PropertyChangedEventHandler handler = this.PropertyChanged; + if (handler != null) + { + handler(this, new PropertyChangedEventArgs(propertyName)); + } + } + } +} diff --git a/Application/FileConverter/OutputType.cs b/Application/FileConverter/OutputType.cs new file mode 100644 index 0000000..f0eb0c9 --- /dev/null +++ b/Application/FileConverter/OutputType.cs @@ -0,0 +1,12 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverter +{ + public enum OutputType + { + None, + Mp3, + Ogg, + Flac, + } +} \ No newline at end of file diff --git a/Application/FileConverter/Properties/Annotations.cs b/Application/FileConverter/Properties/Annotations.cs new file mode 100644 index 0000000..3bbac57 --- /dev/null +++ b/Application/FileConverter/Properties/Annotations.cs @@ -0,0 +1,664 @@ +/* + * Copyright 2007-2012 JetBrains s.r.o. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +using System; + +namespace FileConverter.Annotations +{ + /// + /// Indicates that marked element should be localized or not. + /// + /// + /// + /// [LocalizationRequiredAttribute(true)] + /// public class Foo + /// { + /// private string str = "my string"; // Warning: Localizable string + /// } + /// + /// + [AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)] + public sealed class LocalizationRequiredAttribute : Attribute + { + /// + /// Initializes a new instance of the class with + /// set to . + /// + public LocalizationRequiredAttribute() : this(true) + { + } + + /// + /// Initializes a new instance of the class. + /// + /// true if a element should be localized; otherwise, false. + public LocalizationRequiredAttribute(bool required) + { + Required = required; + } + + /// + /// Gets a value indicating whether a element should be localized. + /// true if a element should be localized; otherwise, false. + /// + [UsedImplicitly] public bool Required { get; private set; } + + /// + /// Returns whether the value of the given object is equal to the current . + /// + /// The object to test the value equality of. + /// + /// true if the value of the given object is equal to that of the current; otherwise, false. + /// + public override bool Equals(object obj) + { + var attribute = obj as LocalizationRequiredAttribute; + return attribute != null && attribute.Required == Required; + } + + /// + /// Returns the hash code for this instance. + /// + /// A hash code for the current . + public override int GetHashCode() + { + return base.GetHashCode(); + } + } + + /// + /// Indicates that the marked method builds string by format pattern and (optional) arguments. + /// Parameter, which contains format string, should be given in constructor. + /// The format string should be in -like form + /// + /// + /// + /// [StringFormatMethod("message")] + /// public void ShowError(string message, params object[] args) + /// { + /// //Do something + /// } + /// public void Foo() + /// { + /// ShowError("Failed: {0}"); // Warning: Non-existing argument in format string + /// } + /// + /// + [AttributeUsage(AttributeTargets.Constructor | AttributeTargets.Method, AllowMultiple = false, Inherited = true)] + public sealed class StringFormatMethodAttribute : Attribute + { + /// + /// Initializes new instance of StringFormatMethodAttribute + /// + /// Specifies which parameter of an annotated method should be treated as format-string + public StringFormatMethodAttribute(string formatParameterName) + { + FormatParameterName = formatParameterName; + } + + /// + /// Gets format parameter name + /// + [UsedImplicitly] public string FormatParameterName { get; private set; } + } + + /// + /// Indicates that the function argument should be string literal and match one of the parameters + /// of the caller function. + /// For example, ReSharper annotates the parameter of . + /// + /// + /// + /// public void Foo(string param) + /// { + /// if (param == null) + /// throw new ArgumentNullException("par"); // Warning: Cannot resolve symbol + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter, AllowMultiple = false, Inherited = true)] + public sealed class InvokerParameterNameAttribute : Attribute { } + + /// + /// Indicates that the method is contained in a type that implements + /// interface + /// and this method is used to notify that some property value changed. + /// + /// + /// The method should be non-static and conform to one of the supported signatures: + /// + /// NotifyChanged(string) + /// NotifyChanged(params string[]) + /// NotifyChanged{T}(Expression{Func{T}}) + /// NotifyChanged{T,U}(Expression{Func{T,U}}) + /// SetProperty{T}(ref T, T, string) + /// + /// + /// + /// + /// public class Foo : INotifyPropertyChanged + /// { + /// public event PropertyChangedEventHandler PropertyChanged; + /// + /// [NotifyPropertyChangedInvocator] + /// protected virtual void NotifyChanged(string propertyName) + /// {} + /// + /// private string _name; + /// public string Name + /// { + /// get { return _name; } + /// set + /// { + /// _name = value; + /// NotifyChanged("LastName"); // Warning + /// } + /// } + /// } + /// + /// Examples of generated notifications: + /// + /// NotifyChanged("Property") + /// NotifyChanged(() => Property) + /// NotifyChanged((VM x) => x.Property) + /// SetProperty(ref myField, value, "Property") + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = true)] + public sealed class NotifyPropertyChangedInvocatorAttribute : Attribute + { + public NotifyPropertyChangedInvocatorAttribute() { } + public NotifyPropertyChangedInvocatorAttribute(string parameterName) + { + ParameterName = parameterName; + } + + [UsedImplicitly] public string ParameterName { get; private set; } + } + + /// + /// Indicates that the value of the marked element could be null sometimes, + /// so the check for null is necessary before its usage. + /// + /// + /// + /// [CanBeNull] + /// public object Test() + /// { + /// return null; + /// } + /// + /// public void UseTest() + /// { + /// var p = Test(); + /// var s = p.ToString(); // Warning: Possible 'System.NullReferenceException' + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Delegate | AttributeTargets.Field, AllowMultiple = false, Inherited = true)] + public sealed class CanBeNullAttribute : Attribute { } + + /// + /// Indicates that the value of the marked element could never be null + /// + /// + /// + /// [NotNull] + /// public object Foo() + /// { + /// return null; // Warning: Possible 'null' assignment + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method | AttributeTargets.Parameter | AttributeTargets.Property | AttributeTargets.Delegate | AttributeTargets.Field, AllowMultiple = false, Inherited = true)] + public sealed class NotNullAttribute : Attribute { } + + /// + /// Describes dependency between method input and output. + /// + /// + ///

Function Definition Table syntax:

+ /// + /// FDT ::= FDTRow [;FDTRow]* + /// FDTRow ::= Input => Output | Output <= Input + /// Input ::= ParameterName: Value [, Input]* + /// Output ::= [ParameterName: Value]* {halt|stop|void|nothing|Value} + /// Value ::= true | false | null | notnull | canbenull + /// + /// If method has single input parameter, it's name could be omitted.
+ /// Using halt (or void/nothing, which is the same) for method output means that the methos doesn't return normally.
+ /// canbenull annotation is only applicable for output parameters.
+ /// You can use multiple [ContractAnnotation] for each FDT row, or use single attribute with rows separated by semicolon.
+ /// + /// + /// + /// + /// [ContractAnnotation("=> halt")] + /// public void TerminationMethod() + /// + /// + /// [ContractAnnotation("halt <= condition: false")] + /// public void Assert(bool condition, string text) // Regular Assertion method + /// + /// + /// [ContractAnnotation("s:null => true")] + /// public bool IsNullOrEmpty(string s) // String.IsNullOrEmpty + /// + /// + /// // A method that returns null if the parameter is null, and not null if the parameter is not null + /// [ContractAnnotation("null => null; notnull => notnull")] + /// public object Transform(object data) + /// + /// + /// [ContractAnnotation("s:null=>false; =>true,result:notnull; =>false, result:null")] + /// public bool TryParse(string s, out Person result) + /// + /// + /// + [AttributeUsage(AttributeTargets.Method, AllowMultiple = true, Inherited = true)] + public sealed class ContractAnnotationAttribute : Attribute + { + public ContractAnnotationAttribute([NotNull] string fdt) : this (fdt, false) + { + } + + public ContractAnnotationAttribute([NotNull] string fdt, bool forceFullStates) + { + FDT = fdt; + ForceFullStates = forceFullStates; + } + + public string FDT { get; private set; } + public bool ForceFullStates { get; private set; } + } + + /// + /// Indicates that the value of the marked type (or its derivatives) + /// cannot be compared using '==' or '!=' operators and Equals() should be used instead. + /// However, using '==' or '!=' for comparison with null is always permitted. + /// + /// + /// + /// [CannotApplyEqualityOperator] + /// class NoEquality + /// { + /// } + /// + /// class UsesNoEquality + /// { + /// public void Test() + /// { + /// var ca1 = new NoEquality(); + /// var ca2 = new NoEquality(); + /// + /// if (ca1 != null) // OK + /// { + /// bool condition = ca1 == ca2; // Warning + /// } + /// } + /// } + /// + /// + [AttributeUsage(AttributeTargets.Interface | AttributeTargets.Class | AttributeTargets.Struct, AllowMultiple = false, Inherited = true)] + public sealed class CannotApplyEqualityOperatorAttribute : Attribute { } + + /// + /// When applied to a target attribute, specifies a requirement for any type marked with + /// the target attribute to implement or inherit specific type or types. + /// + /// + /// + /// [BaseTypeRequired(typeof(IComponent)] // Specify requirement + /// public class ComponentAttribute : Attribute + /// {} + /// + /// [Component] // ComponentAttribute requires implementing IComponent interface + /// public class MyComponent : IComponent + /// {} + /// + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = true, Inherited = true)] + [BaseTypeRequired(typeof(Attribute))] + public sealed class BaseTypeRequiredAttribute : Attribute + { + /// + /// Initializes new instance of BaseTypeRequiredAttribute + /// + /// Specifies which types are required + public BaseTypeRequiredAttribute(Type baseType) + { + BaseTypes = new[] { baseType }; + } + + /// + /// Gets enumerations of specified base types + /// + public Type[] BaseTypes { get; private set; } + } + + /// + /// Indicates that the marked symbol is used implicitly (e.g. via reflection, in external library), + /// so this symbol will not be marked as unused (as well as by other usage inspections) + /// + [AttributeUsage(AttributeTargets.All, AllowMultiple = false, Inherited = true)] + public sealed class UsedImplicitlyAttribute : Attribute + { + [UsedImplicitly] public UsedImplicitlyAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + [UsedImplicitly] + public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] public UsedImplicitlyAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) { } + + [UsedImplicitly] public UsedImplicitlyAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; } + + /// + /// Gets value indicating what is meant to be used + /// + [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + /// + /// Should be used on attributes and causes ReSharper + /// to not mark symbols marked with such attributes as unused (as well as by other usage inspections) + /// + [AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = true)] + public sealed class MeansImplicitUseAttribute : Attribute + { + [UsedImplicitly] public MeansImplicitUseAttribute() + : this(ImplicitUseKindFlags.Default, ImplicitUseTargetFlags.Default) { } + + [UsedImplicitly] + public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags, ImplicitUseTargetFlags targetFlags) + { + UseKindFlags = useKindFlags; + TargetFlags = targetFlags; + } + + [UsedImplicitly] public MeansImplicitUseAttribute(ImplicitUseKindFlags useKindFlags) + : this(useKindFlags, ImplicitUseTargetFlags.Default) + { + } + + [UsedImplicitly] public MeansImplicitUseAttribute(ImplicitUseTargetFlags targetFlags) + : this(ImplicitUseKindFlags.Default, targetFlags) { } + + [UsedImplicitly] public ImplicitUseKindFlags UseKindFlags { get; private set; } + + /// + /// Gets value indicating what is meant to be used + /// + [UsedImplicitly] public ImplicitUseTargetFlags TargetFlags { get; private set; } + } + + [Flags] + public enum ImplicitUseKindFlags + { + Default = Access | Assign | InstantiatedWithFixedConstructorSignature, + + /// + /// Only entity marked with attribute considered used + /// + Access = 1, + + /// + /// Indicates implicit assignment to a member + /// + Assign = 2, + + /// + /// Indicates implicit instantiation of a type with fixed constructor signature. + /// That means any unused constructor parameters won't be reported as such. + /// + InstantiatedWithFixedConstructorSignature = 4, + + /// + /// Indicates implicit instantiation of a type + /// + InstantiatedNoFixedConstructorSignature = 8, + } + + /// + /// Specify what is considered used implicitly when marked with or + /// + [Flags] + public enum ImplicitUseTargetFlags + { + Default = Itself, + + Itself = 1, + + /// + /// Members of entity marked with attribute are considered used + /// + Members = 2, + + /// + /// Entity marked with attribute and all its members considered used + /// + WithMembers = Itself | Members + } + + /// + /// This attribute is intended to mark publicly available API which should not be removed and so is treated as used. + /// + [MeansImplicitUse] + public sealed class PublicAPIAttribute : Attribute + { + public PublicAPIAttribute() { } + public PublicAPIAttribute(string comment) { } + } + + /// + /// Tells code analysis engine if the parameter is completely handled when the invoked method is on stack. + /// If the parameter is a delegate, indicates that delegate is executed while the method is executed. + /// If the parameter is an enumerable, indicates that it is enumerated while the method is executed. + /// + [AttributeUsage(AttributeTargets.Parameter, Inherited = true)] + public sealed class InstantHandleAttribute : Attribute { } + + + /// + /// Indicates that a method does not make any observable state changes. + /// The same as + /// + /// + /// + /// [Pure] + /// private int Multiply(int x, int y) + /// { + /// return x*y; + /// } + /// + /// public void Foo() + /// { + /// const int a=2, b=2; + /// Multiply(a, b); // Waring: Return value of pure method is not used + /// } + /// + /// + [AttributeUsage(AttributeTargets.Method, Inherited = true)] + public sealed class PureAttribute : Attribute { } + + /// + /// Indicates that a parameter is a path to a file or a folder within a web project. + /// Path can be relative or absolute, starting from web root (~). + /// + [AttributeUsage(AttributeTargets.Parameter)] + public class PathReferenceAttribute : Attribute + { + public PathReferenceAttribute() { } + + [UsedImplicitly] + public PathReferenceAttribute([PathReference] string basePath) + { + BasePath = basePath; + } + + [UsedImplicitly] public string BasePath { get; private set; } + } + + // ASP.NET MVC attributes + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC action. + /// If applied to a method, the MVC action name is calculated implicitly from the context. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcActionAttribute : Attribute + { + [UsedImplicitly] public string AnonymousProperty { get; private set; } + + public AspMvcActionAttribute() { } + + public AspMvcActionAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC araa. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcAreaAttribute : PathReferenceAttribute + { + [UsedImplicitly] public string AnonymousProperty { get; private set; } + + [UsedImplicitly] public AspMvcAreaAttribute() { } + + public AspMvcAreaAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC controller. + /// If applied to a method, the MVC controller name is calculated implicitly from the context. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcControllerAttribute : Attribute + { + [UsedImplicitly] public string AnonymousProperty { get; private set; } + + public AspMvcControllerAttribute() { } + + public AspMvcControllerAttribute(string anonymousProperty) + { + AnonymousProperty = anonymousProperty; + } + } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC Master. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcMasterAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC model type. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcModelTypeAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC partial view. + /// If applied to a method, the MVC partial view name is calculated implicitly from the context. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcPartialViewAttribute : PathReferenceAttribute { } + + /// + /// ASP.NET MVC attribute. Allows disabling all inspections for MVC views within a class or a method. + /// + [AttributeUsage(AttributeTargets.Class | AttributeTargets.Method)] + public sealed class AspMvcSupressViewErrorAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC display template. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcDisplayTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. Indicates that a parameter is an MVC editor template. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter)] + public sealed class AspMvcEditorTemplateAttribute : Attribute { } + + /// + /// ASP.NET MVC attribute. If applied to a parameter, indicates that the parameter is an MVC view. + /// If applied to a method, the MVC view name is calculated implicitly from the context. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method)] + public sealed class AspMvcViewAttribute : PathReferenceAttribute { } + + /// + /// ASP.NET MVC attribute. When applied to a parameter of an attribute, + /// indicates that this parameter is an MVC action name. + /// + /// + /// + /// [ActionName("Foo")] + /// public ActionResult Login(string returnUrl) + /// { + /// ViewBag.ReturnUrl = Url.Action("Foo"); // OK + /// return RedirectToAction("Bar"); // Error: Cannot resolve action + /// } + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Property)] + public sealed class AspMvcActionSelectorAttribute : Attribute { } + + // Razor attributes + + /// + /// Razor attribute. Indicates that a parameter or a method is a Razor section. + /// Use this attribute for custom wrappers similar to + /// + /// + [AttributeUsage(AttributeTargets.Parameter | AttributeTargets.Method, Inherited = true)] + public sealed class RazorSectionAttribute : Attribute { } + +} \ No newline at end of file diff --git a/Application/FileConverter/Properties/AssemblyInfo.cs b/Application/FileConverter/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..cea7824 --- /dev/null +++ b/Application/FileConverter/Properties/AssemblyInfo.cs @@ -0,0 +1,55 @@ +using System.Reflection; +using System.Resources; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Windows; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("FileConverter")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("FileConverter")] +[assembly: AssemblyCopyright("Copyright © 2014")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// In order to begin building localizable applications, set +// CultureYouAreCodingWith in your .csproj file +// inside a . For example, if you are using US english +// in your source files, set the to en-US. Then uncomment +// the NeutralResourceLanguage attribute below. Update the "en-US" in +// the line below to match the UICulture setting in the project file. + +//[assembly: NeutralResourcesLanguage("en-US", UltimateResourceFallbackLocation.Satellite)] + + +[assembly: ThemeInfo( + ResourceDictionaryLocation.None, //where theme specific resource dictionaries are located + //(used if a resource is not found in the page, + // or application resource dictionaries) + ResourceDictionaryLocation.SourceAssembly //where the generic resource dictionary is located + //(used if a resource is not found in the page, + // app, or any theme specific resource dictionaries) +)] + + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Application/FileConverter/Properties/Resources.Designer.cs b/Application/FileConverter/Properties/Resources.Designer.cs new file mode 100644 index 0000000..d240821 --- /dev/null +++ b/Application/FileConverter/Properties/Resources.Designer.cs @@ -0,0 +1,71 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace FileConverter.Properties +{ + + + /// + /// A strongly-typed resource class, for looking up localized strings, etc. + /// + // This class was auto-generated by the StronglyTypedResourceBuilder + // class via a tool like ResGen or Visual Studio. + // To add or remove a member, edit your .ResX file then rerun ResGen + // with the /str option, or rebuild your VS project. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "4.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources + { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() + { + } + + /// + /// Returns the cached ResourceManager instance used by this class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager + { + get + { + if ((resourceMan == null)) + { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("FileConverter.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Overrides the current thread's CurrentUICulture property for all + /// resource lookups using this strongly typed resource class. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture + { + get + { + return resourceCulture; + } + set + { + resourceCulture = value; + } + } + } +} diff --git a/Application/FileConverter/Properties/Resources.resx b/Application/FileConverter/Properties/Resources.resx new file mode 100644 index 0000000..af7dbeb --- /dev/null +++ b/Application/FileConverter/Properties/Resources.resx @@ -0,0 +1,117 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=2.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Application/FileConverter/Properties/Settings.Designer.cs b/Application/FileConverter/Properties/Settings.Designer.cs new file mode 100644 index 0000000..285c711 --- /dev/null +++ b/Application/FileConverter/Properties/Settings.Designer.cs @@ -0,0 +1,30 @@ +//------------------------------------------------------------------------------ +// +// This code was generated by a tool. +// Runtime Version:4.0.30319.18444 +// +// Changes to this file may cause incorrect behavior and will be lost if +// the code is regenerated. +// +//------------------------------------------------------------------------------ + +namespace FileConverter.Properties +{ + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "11.0.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase + { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default + { + get + { + return defaultInstance; + } + } + } +} diff --git a/Application/FileConverter/Properties/Settings.settings b/Application/FileConverter/Properties/Settings.settings new file mode 100644 index 0000000..033d7a5 --- /dev/null +++ b/Application/FileConverter/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + \ No newline at end of file diff --git a/Application/FileConverter/ReadMe.txt b/Application/FileConverter/ReadMe.txt new file mode 100644 index 0000000..9c5bcc2 --- /dev/null +++ b/Application/FileConverter/ReadMe.txt @@ -0,0 +1,5 @@ +------------------------------------------------------------------------------- + File Converter v 0.x +------------------------------------------------------------------------------- + +This program use ffmpeg. diff --git a/Application/FileConverter/Settings.StyleCop b/Application/FileConverter/Settings.StyleCop new file mode 100644 index 0000000..67f607a --- /dev/null +++ b/Application/FileConverter/Settings.StyleCop @@ -0,0 +1,24 @@ + + + + + + + False + + + + + False + + + + + False + + + + + + + \ No newline at end of file diff --git a/Application/FileConverterExtension/FileConverterExtension.cs b/Application/FileConverterExtension/FileConverterExtension.cs new file mode 100644 index 0000000..c4c774c --- /dev/null +++ b/Application/FileConverterExtension/FileConverterExtension.cs @@ -0,0 +1,140 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverterExtension +{ + using System.Diagnostics; + using System.IO; + using System.Runtime.InteropServices; + using System.Text; + using System.Windows.Forms; + + using Microsoft.Win32; + + using SharpShell.Attributes; + using SharpShell.SharpContextMenu; + + [ComVisible(true), Guid("AF9B72B5-F4E4-44B0-A3D9-B55B748EFE90")] + [COMServerAssociation(AssociationType.AllFiles)] + public class FileConverterExtension : SharpContextMenu + { + private string fileConverterPath; + + protected override bool CanShowMenu() + { + foreach (string filePath in this.SelectedItemPaths) + { + string extension = Path.GetExtension(filePath); + if (string.IsNullOrEmpty(extension)) + { + continue; + } + + extension = extension.Substring(1).ToLowerInvariant(); + switch (extension) + { + case "mp3": + return true; + + case "wav": + return true; + + case "ogg": + return true; + + case "flac": + return true; + } + } + + return false; + } + + protected override ContextMenuStrip CreateMenu() + { + ContextMenuStrip menu = new ContextMenuStrip(); + + ToolStripMenuItem fileConverterItem = new ToolStripMenuItem + { + Text = "File Converter" + }; + + { + ToolStripMenuItem subItem = new ToolStripMenuItem + { + Text = "To Ogg", + }; + + fileConverterItem.DropDownItems.Add(subItem); + subItem.Click += (sender, args) => this.ConvertFiles(FileType.Ogg); + } + + { + ToolStripMenuItem subItem = new ToolStripMenuItem + { + Text = "To Mp3", + }; + + fileConverterItem.DropDownItems.Add(subItem); + subItem.Click += (sender, args) => this.ConvertFiles(FileType.Mp3); + } + + { + ToolStripMenuItem subItem = new ToolStripMenuItem + { + Text = "To Flac", + }; + + fileConverterItem.DropDownItems.Add(subItem); + subItem.Click += (sender, args) => this.ConvertFiles(FileType.Flac); + } + + menu.Items.Add(fileConverterItem); + + RegistryKey registryKey = Registry.CurrentUser.OpenSubKey(@"Software\FileConverter"); + this.fileConverterPath = null; + if (registryKey != null) + { + this.fileConverterPath = registryKey.GetValue("Path") as string; + } + + return menu; + } + + private void ConvertFiles(FileType ouputType) + { + this.fileConverterPath = @"D:\Projects\FileConverter\FileConverter\Application\FileConverter\bin\Debug\FileConverter.exe"; + if (string.IsNullOrEmpty(this.fileConverterPath)) + { + MessageBox.Show(string.Format("Can't retrieve the file converter executable path. You should try to reinstall the application.")); + return; + } + + if (!File.Exists(this.fileConverterPath)) + { + MessageBox.Show(string.Format("Can't find the file converter executable ({0}). You should try to reinstall the application.", this.fileConverterPath)); + return; + } + + ProcessStartInfo processStartInfo = new ProcessStartInfo(this.fileConverterPath); + + processStartInfo.CreateNoWindow = false; + processStartInfo.UseShellExecute = false; + processStartInfo.RedirectStandardOutput = false; + + // Build arguments string. + StringBuilder stringBuilder = new StringBuilder(); + stringBuilder.Append("--output-type "); + stringBuilder.Append(ouputType.ToString()); + + foreach (var filePath in this.SelectedItemPaths) + { + stringBuilder.Append(" \""); + stringBuilder.Append(filePath); + stringBuilder.Append("\""); + } + + processStartInfo.Arguments = stringBuilder.ToString(); + Process exeProcess = Process.Start(processStartInfo); + } + } +} diff --git a/Application/FileConverterExtension/FileConverterExtension.csproj b/Application/FileConverterExtension/FileConverterExtension.csproj new file mode 100644 index 0000000..4145693 --- /dev/null +++ b/Application/FileConverterExtension/FileConverterExtension.csproj @@ -0,0 +1,68 @@ + + + + + Debug + AnyCPU + {0C44CA69-42D6-4357-BDFD-83069D1ABA2F} + Library + Properties + FileConverterExtension + FileConverterExtension + v4.5 + 512 + + + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + + + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + + + true + + + FileConverterExtensionKey.snk + + + + ..\..\Middleware\SharpShell\SharpShell.dll + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Application/FileConverterExtension/FileConverterExtensionKey.snk b/Application/FileConverterExtension/FileConverterExtensionKey.snk new file mode 100644 index 0000000000000000000000000000000000000000..cc36cec88449ff8747e845771034a3ef62ea3821 GIT binary patch literal 596 zcmV-a0;~N80ssI2Bme+XQ$aES1ONa50098m&$I|R>?}qFg0qgP-gt8IEYGPhizPt|C6xXJr7bs}+qlE(i z(!)V^IUnvlKOnL3_HQYB{fqiFAOpAosih6Lyn}PGo+|mO7q=MsX4W35x<^X7<~K+I zFm4%8LC2`oPZW4h2bVRn%?+FH-g133I>QBfYwmxZ1_a7k2=4E;i_LZnMW5l2KK9XD z!aMkA#P-hd?M1Mbgq^jHsl?ZSXTxO3{u49GEK zN@HN>m0qjl4;C?WHq$D6J^S*=o9P^@FECuOL0kM?Gf(ckjGP(c)}T%}ay8)L@!g1p z?hwV@WqH8?@Vzr+)B`!ou=6f3^tF;WlfkK?J;DGUH|t_sAWiMSd^Cgrtp@g!T+S)i z*%$0=14VRnI4!gT`Pzz<-DnGToyz~#4#jYELs?hiKM{e0McjH{q-o{N>Ge=57n(Tl i-VM|hW%Y~1fbe;I3|mW~-v#!YnBgdu!o$dSh5Aq80VW&( literal 0 HcmV?d00001 diff --git a/Application/FileConverterExtension/FileType.cs b/Application/FileConverterExtension/FileType.cs new file mode 100644 index 0000000..fee445d --- /dev/null +++ b/Application/FileConverterExtension/FileType.cs @@ -0,0 +1,13 @@ +// License: http://www.gnu.org/licenses/gpl.html GPL version 3. + +namespace FileConverterExtension +{ + public enum FileType + { + Undefined, + + Mp3, + Ogg, + Flac, + } +} \ No newline at end of file diff --git a/Application/FileConverterExtension/Properties/AssemblyInfo.cs b/Application/FileConverterExtension/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..f183522 --- /dev/null +++ b/Application/FileConverterExtension/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("FileConverterExtension")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("FileConverterExtension")] +[assembly: AssemblyCopyright("Copyright © 2015")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("86f3928d-94ef-4d27-8235-1074894e9b5f")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Build and Revision Numbers +// by using the '*' as shown below: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Installer/Extension.wxs b/Installer/Extension.wxs new file mode 100644 index 0000000..42bb1af --- /dev/null +++ b/Installer/Extension.wxs @@ -0,0 +1,23 @@ + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Installer/GenerateExtensionWxsFile.bat b/Installer/GenerateExtensionWxsFile.bat new file mode 100644 index 0000000..d99f141 --- /dev/null +++ b/Installer/GenerateExtensionWxsFile.bat @@ -0,0 +1 @@ +"C:\Program Files (x86)\Wix Toolset v3.9\bin\Heat.exe" file "..\Application\FileConverterExtension\bin\Debug\FileConverterExtension.dll" -dr INSTALLFOLDER -srd -gg -sfrag -suid -out "Extension.wxs" -b "..\Application\FileConverterExtension\bin\Debug\" \ No newline at end of file diff --git a/Installer/Installer.wixproj b/Installer/Installer.wixproj new file mode 100644 index 0000000..9739d7b --- /dev/null +++ b/Installer/Installer.wixproj @@ -0,0 +1,52 @@ + + + + Debug + x86 + 3.9 + f14673df-df38-44b4-ab1d-99a59182c24c + 2.0 + Installer + Package + $(MSBuildExtensionsPath32)\Microsoft\WiX\v3.x\Wix.targets + $(MSBuildExtensionsPath)\Microsoft\WiX\v3.x\Wix.targets + + + bin\$(Configuration)\ + obj\$(Configuration)\ + Debug + + + bin\$(Configuration)\ + obj\$(Configuration)\ + + + + + + + + $(WixExtDir)\WixUIExtension.dll + WixUIExtension + + + + + FileConverter + {d27a76d2-43e4-43cc-9da3-334b0b46f4e5} + True + True + Binaries;Content;Satellites + INSTALLFOLDER + + + + + \ No newline at end of file diff --git a/Installer/Product.wxs b/Installer/Product.wxs new file mode 100644 index 0000000..0d5640c --- /dev/null +++ b/Installer/Product.wxs @@ -0,0 +1,56 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Middleware/SharpShell/ServerManager/Apex.WinForms.dll b/Middleware/SharpShell/ServerManager/Apex.WinForms.dll new file mode 100644 index 0000000000000000000000000000000000000000..74ef1a501cd7fe3c2978a3a52f32270cbedf8765 GIT binary patch literal 34304 zcmeIb3wTu3)i=J*nKNfDxsaKJWC92S1Q;;Ha8bab5;7AK$&F07DHeugAS07ZoS6XO zqLYdgDz;#))fQXS`nIUG*w#vGZBfydwzk!3TdlR)YQ5C9+RJNgy?np5_L<3q(Ei`& z`G3#%Jm2$t1M@q3t-bczYv0zsoO32EmmDM;5gGV?@Bz_rT=}y^@IONa(Z!R#RZL%Z zJwExk*8KS7&YoDx-=9ouPDXnDU6H=NMB2YG>Q4^z`D1bZV=C@<4&&;__XxghogWun*^Q9c&sTZ@U-19=9YVR5 zTtieM|A(&@$+GzLL+^4993eW!6><9K1W_S)Z+w<$!s&7UiS`pY^WvSL8}sOzbaZ?FW z_{U%8zdPmg9WVPXaJ==!iw+bF?0J07x%Zz_*1PjX&$#m6jPJVSsZ(2?J95ug_uT!Z zjaQa`D*VLYO*fvuATsO4(7VqcUGCa{eTSZ?By#&*9<;v^ScncZeOA(9I+=OpIK)dt zYCJ--z^XOr0jmspQbVWMeHJQOAB#^4jqct(k;!r6CQel36ecTnPvuK_`K0Xuh`Un| za_>gJHgx}+(B^-R0Yi%NqNj26*xl3l5}1SpdH~8yJz0cY5u&>Cl%Mq=&dB4AQ(QzD zy1tVmcTeWwff~-IV%aj6J04BL-&DB$| z$-SFX&nm5TkQ3E_{~p~In1KjeA^;4`lpw0iUEtLMXXmIwuO6t*QAJ)`U^b|VwR)gN zu8DJS(RXn*N~*E*`V^(_;<^;+$~A%7oRr09oxZh!Ik+eb^qtZ&QUi&(U|U+f6qpAp z7MKrIs=+!}Smyyprsk>(EXYZUNn0%QILj?5^c!~qL&1&mqvlN1iAldl`{-OJJGqr% zc;=$i`H*o3J_H1PLebN$+FH!%cX9y}7a*v(rp39CBUS0S9(`*H^6J93wlKd2))ZOP zMJ&0t)X0mpf=f8&(lw=ai)Nixu+EAyEdv}LyVGM&EM5o15}F|IJtVzr4a(SQhBVi_<1 zm*cKJ8+!f7M)k%-6GvRk0H^G(K2H}S(G243nIlY4qAfYm0zJTlh^joz8dJ|2+KQ-I zHrR=Jl8>sJQTEKPR0S9nQ4L)f0wxOGrgWLKBdbelvARy*$>VzLyh2^|do|3)kvCkxo%U=PTFm(8iGnWL^!`$k3ob3wrao5@n*FTUQb0PI-zWmdu{nRDS~Ad zQlhSmSyPZw0)#$d&{5Qvfj(lZoL6RfWLrs|n>M@zuW|@EOg93b#HBE`3hIkorX#f) zfy5d>d8u*s48voT2d;-isoi4_tOdK&bR{mq)ng_u<%?0VrW8`nxlh?j9UeyreN(1H zH?CfM&-UrA#5zdM!u2xi`eD8%F)Q?^)+4whJ8y`Uqvws%T02Fd%g+5iwGke*wj`|YkH9LJ#5T2kRJHvJo~n@l0o6atxCx~c1HrE-l`Hf z(VZZs>*#|R)Fw)~3-tNLAAIn^^MxKqH9B5mH#pDDA`Kl~rxtprK`TUsh|l!k>g4(s z-8L^Ju4HwlYCnT~h<8am%44|A>LR$GR3n=UhiLK`=GL6`uuTQ#X;%AI!vjfF;C#s0 zs*B;ZFhwEtZb^WIr~@@VB>)EMLop;E_RU287%#9-+;pQ}|0@uRnvL$uJA-XNev9PPC+f@t|fxMNV>; zCqBl}5N7{{K|=+o58EX7ISzd%TQkeHMGtgBX3M2+a|+@wS_8~nG{?aNon0i9#4NdF zZGjS5D{-}1kv!&-O9~}{0j<1p+H&dIA{M)<{*qF|X$9;qD}bpw=CQ{-W=vL?v!?5) z!3|s?Y_Cb^db}S%`*GoTQOMWCwNQ*1imis{RvG!7KAlnrz}n3+_kn>_b>xp`*=NL0Q)VlrhN0k|)7*jQda zl)}~`u@ysz`?}M#8Hsi&Og6q);!&zxJj#H=ay<9BF?s28ebuY_Dr-ew)z8#dPfsU( z^?#5KLmG9f?8)Vag7Da2F7m^)GkR>Co=)=ncj+)RrK2S=c%}c_WVMglOQCa{0Zdfl z33yPL6G=VY{(DHmDzM0M~%I@OrRz--z`3PQe87 z#N@%@d)_!Gl&aByxn^d;8 zJar2v_#A*;FS1rHN&;XYXT^{JD(>?vd9mf&0!Kixw=sETX1O~dk@U;iq!O^9E>RWo z!LCzkWcSw~0^j#_zNBu2uHE->(Aq>^$5k@PHM|?d+ug(faodKyr$EKM(eD`o++0>P6L(^m=4SGR3N)AfjNuD!@r@jsEqsDF0P!wQAA*2 zE#W&6)&q9|c{6%9uGn9RT?wSZqT%e-UL$Z1f`v}gQC?ojt_JyX^;XYtVtE_*3d`BO zcG2t0%i|KPc17IbOt8mWlb7e30;oL(=IkTS7kiEO%TZzD)f&KB8^dO`7MM@nHxXPK zj(+siy-2eAyU1J*pzhszxmp$lCUUi{%8osBJ##kvEQW#d@pkG#`mv~kz&F5ir%-q< zky_KBFm8l#F%xK#To|HmC#r+Ko|p%!{a#o5Cl+tXkcrd zXr8?tOLuq>caao=7xu2ivcxsQiF`3TxX<6EmTe}MZDzK~P9g$*jw@hz4Y%)Ub4u;*{qNF!xa@rsquoqB4yn|S0U6Y%G3)1g z;3pt>I>2BzQ$OYCCjh%qZ#bxW-^7?UQ%^GcXUs<3h+nZ&6Y8ZBwtMOQv3@ueJ%Bbb z%e`bCU^4I&#QnUq3~T{^x|epMu?@8cdm3@G^|DzOQ}zpR;qX^>+K1~n=q=;drGfuCu}tma1dC5fx-YX zcz}Vb;4X)&nZS6$742lF*J0CmZYP615+5O8D4Du+L(>-M0};SDGf{AQ)opMmHY>(x z=u00#Xu2*D{`KYWYxp1dGI)xW$+9?4uQswGHAj9aF3y%h_iAE2yEl^w*l7gdHiUo` zMgYD@2rgEDi>0#zHLGVT%hUntRWQx)>bzqyi*zTu57Sj`x}>Jj7(91OLU|^j+UeJ8uE#P3-l2zFM9SD2_ty^2c) zehl7=`?if1;5rd~^Gasw7^<&9qS|2wkjk8;Uv)Lu@Id{brYjjU@j65-0jv)Hz?x}k z_~NA+Hwiw4_->tFQ(H5ycHW#t%&}7(cw#2eR1CCgWd5Z9!r^o>*0(vu5>Isyy@}*g zSBB|ir@FT_b=k_MAjg5esR(gPSC7P3pA;%q`t&Wzw)sBm1W(CJz2*5 z7t4wZ-SmmE%>RbqJ3udm$~iVu&N^=|XPwK(SC2R8q6v&0g2x5-pSA5Qla2^JDEOS< z+kzz%S-whe?nIVcF4!%2mEcW+Kbd&nMA$#^)rr5MF>tRYT{vmtB$GZ2ET?@EK01jl zIX;PX{!s9@f`0|N$?4~M81Lt@*ZR5a9})}+_6lAtxKHpE!EuvWathE*`zLcfd{*!Y z!9M^^dT;W?NpA8@>DHHNADY6pePRk*a@Q2L>L%Th)bC#k8er&@86iKsSA+ifjA9Dz@RJs>iEL@=xPFke9{rI3xZcIDw|1zcY0NLtr5&-j`@JgoS=Rt-`n|gRjsbiD?g#mE=ck z3C?E@;LKwJQ;7SFXqicK=~ietB3jM?#c_Aj{YZBXcDbzchoW;Hs9~LpkZ%TY&m*0S zE(FEtUKX7f(jwf?E5TTvg8lghP@MY*RHTiiD=ex?E7B@y8}0*hy7NJuMcZ*_oT;#O z0Q2y6Y7?r*qQatO5Y%MEt(LftXj~IlQcP^w2g*f5pjgX6iQ7*}Np~Z1m_|1+g}B=! z?q=F0cHRlfL$`tAxUXwm_Ai3sdifsW2s=N-p$tzU_exNEMe=u|H$z(pI%Td`YtHeIbJW)W`eo_6wyrme#AXOw?dL=o={JM=K5SJ zT7E{4VMX%`^siN!-{?ia*9G4dEU++ zd>^FQQ#NM81Q@M0Pq*)An*mjKMB4q ze1~H<_+Cc_=odW4!5;iV#~yGVLM-b)3!29|zYLrrI7e`);3{C&hHcItK;|mJYk(^< z2b^sA&4PCb-YfWs;N!q-+B@y9A?@={#(O3F62jTs-*x^Se7B3yCpcYjzF<(WQ*g83 zcERfeZxOsx@VMY3f>;I|Q#4{H)+t1WyP)A^2Ot zKMUFm{;rucuD}gHIJuw|erLLb0}?(*!gB=Y37#joNU%<@Nw7_DrQkZjje;@31aLB) zSD4l(Q>gGNxQw2{j{+S<*8@XE+}8bq&lG(ToLKQYz^%p1SAFKX;`hM0p;)tN^jL9$ zEnENLG1F|TG7-VV7&n#@*NmBGE2kR;?-0&0!3P9?DEK@ut07bJ5oowU@R;D^g0Bgh z9**@1P7w?Wt_7~hq&#knf~$ZU{nm3Fwyp4T-`)z$>VMSxZD{y`;Io2%6ttBxf1=>I zg3Ev=tuEzO*dW+b%I(rGxV`j*l$ytQru0#yecs8qSHgz`KLgaLuIwE>oBNuw8e>(a zTQCXC*5|3Rg$Vz=jBEJSvc-l;|0v^p-!J1Fjj`zeC7!V;Mad*anl+aB=LpUdTm+m< z-yPczJ&vMXK-G@L<-4^xbZ7aOjmh+2`Tf9$%fE}*`M$pb+kKqlH7y{-uJblt;;GI=T`34JaqGnV+9_15;%wcRatGvgz*Qe$x**D{z7wd)bEV{&ZGWlyhrnMac?8{ zb8{5gb&YozD!)?ur{&C4QB&-N8n3t&b&mZdT9Ts{gIY>I^)ur}I%q#f3)0ILb&GwW zwv5mv@Y(CT-yYPO=!Zg`qzCPdpwtbiA$k;X7gHHev~-eQwYPu@V70~%l)VXRIgP7Q zaqrs0S~CSL%4e?CTIdansshzY3#EehP^}r%+UPq%ounmZ7}T>C)e5SeUbCovbG^2L z{vp&}XNzN>hAj?nO=z$4QpW*M<1H%YIHZMXszvQ`+z4u=MSa3?SnH(AEb2>+Mo|3W z_S@{dS6i8*;?8erYjV^T&hKh#b5z=R1XPb`;rjfgb_ty&o#aNk#r~ppnI(Cn|4ru~ zwe_@E;#BQ+(U*l9qU{AM^e%eHq7H%Tre9jrw+hziQF3Behw{-=1?%p3Brrs#n zr1#KGLJiS71$}yqzOCY%I|~o!m(xj$`efk>P=B|my9y6$Tj)KDI#t*RN)F#qgRdYi zPQ}uh_d4H3T%3Fs(|yFERJyBkaepg%LBA$Pl^4IFe>6vNx@+lCB0oRc! zgItY(>xiEc;}I~o_%Hg$=|@%^kAQ>pON-)ueTX8}EP0Z61YA#hgc_o{;veguq%T<1 z>f#slPti%C_BwAZw%a~U?^@JXLES|2#i{Id{-k(}?PiKw)N`OdL$_Mg8^vR7pQWP~ z^)$u@tDKfVfwK}O&QY&ia!~;(f`_*1-4sq)VpIYw0$m*T5h{NN4ZPZ*uIpb zCYD5Ocjc%>C70W9280jmysV_(b}UC-QL@eURr;;ue#m!W`964MzCXAevm4kcQ3;H)%z4(G7rKfB--M6TFOMh;AC`Ub5`hx9bj`~6A8@BJ~s9%;2 z(T{S}?@Hgc{Uk^ItyD8`EQAkx8>6hicsfUU%PI{V8d`Bv%cf%Xh~(M%J4)xMakk&l z)rxY?E*oomiLMoD$hn|w9H<*|l0ofddO;}FlV7F}EQ-D9@2R+!b5x%F6`CN_N%}(_d7;og_dd7Adf2KV$%_-0KCVfFD z)zWX$w}l#_%-EpzCe_a6q$lZ%W7isQ(&Bkcv9H@;yhZDTVqX`-%$ZSfPWESirF|B~ z{_L-G$fABc_OSLhy4j+h8`}u#Hj8>4aet@d7Ue4%GX73)TGVV%|4q|m0#^O=ZMr}x zRfe}IEz}TQTz` z4#4O4+Jl%=|4EC4dW=2;$$!#Hq4qj|Tz<;-B%qCM)iZ^26G{sLzUf zr@Rr=HY?7o*r&ZqS6Ol86$e1=v*M;B?maqa#mz(9dvvoEx1{1H#`|=u71vhr6sS9` zxDQwS1t$Yvwc_Fx&l(@l147;C+);78LE85$$wL*t0reA0^3IBvK>gB+d!*uZL(^Wc z;(k=|Cs40haZe*o*WR+?evdd^`==H6cEw?AGW11KpH7#r5mbRtd!6Hb`!qxISyYwp zfMIA?OI;tLD`y-nFtlqe>I5jeHccc|+nU;Zp?KEz+f8koilbL6r`y#@=ju{EuiOB% zk%{G_hP@bbTnJ}5V-VJky#S|Gocl!PTRJpPm-B(bM1<#F834 zFZh2lRep=)_lnVNbY}ZC$}juB3%@Mo`U6m>ze=m|-7SMmpxqiZ9)vMYCvcmNj-4T~ z)f05Tjm|?@qYc8j9B8AYaJCEQY6&ZC*Gc$O!sp&=vwClS`{vu6U&bSn>W&E-ay$yF z3_1z4OI{{DE}E6huf*n;grn?4D&&Fne=OZS^2a$E%)Y;=~SQr6CpR8zrWf5jy_TVm%6 zs@hP!LXE!so^bwIJnrTduukQj&POVYMDZ}}CpBVDc8rH4d~u%U{MuGwRWoXob^b@m z(P>9>4q}I->n`{{oB z4D%Gt@SkH=f-}xm2~H3@ll$!pz;E|2Ffq<_dlOjYvB_*X@51&|8ZuW{xI^SKlaE8@;N6WXUjT=9aW0)tB?fg~Kf6$hzt9jY3~KuY-$E^ob?n!tOd0Q} z)M}?pMtJ#@fa8$vF=`w$Y1Nc-fib~dz?+fkfOf0kQDC#9Q0lo%aHimX{qIw{9Uipo zF?|IYQ-_QdQ~|t|W=u^xTzc))!?2`&YNIxjdZ%9Pcu3ziHHe4F87I)SQ?GYa(alru zaFo#i&Qo-KRn%1{ z;di7jx%9iL4#4KGSB-bf(I2V0+@;xA=M#|G?RtXVtlH~}Aj~qnC-m63>@I!wv~Rjz z6g@8ef@vpQXct)P(i^9BqIK3G)}?Qn7St*sAJit>K0fUL@Fw6)+k?}7k^gjYHBp@L|Wbx zy(RtaE$MrMdd2iA_aYnju4>fzEcbk=bCV;ZOZ z7*ZVvXR)-@t;jcKcyR8rMvvKkF#T)pnC-dg`yl_u^l!SaKuH_5LEy}SAS93J&A{b2 z-{qR@6wW%~bW1oc;X}5r8CwfH7&|))4%sfB@zH{3z<<{8$UY{GFvcLgGvkqhTcP<> zL0anYkZpY63CPb3Y%SO&+K$>*1YRgOYFizk!Zdw2;3>SgyeWqa{NAWbm9DfHUCuP zpArqfq#r}`bCUK2`Wf`UD*E4$v~NnLLSYqAuK#Tn#ML)&Wbj2(V0J z`+YdWchLmx9ccFB(JB{JX>3(Mn-8qk76EIu3xV^s_aU=Tv*|8ctT};8v?5?o^8y>S z3ShG~0oX3ssZB84NmSEmkWmJ zI`A*0`+;5b7;p>y6u6V#0$xq;1FxlS==mh|7S+>T(AYh@HMabA2_Mx&gT@+8 z0e|m4C7jo^F0;1aHSJP!YQgO~r<#frz(%?nr)Cq)t8HQWt?LBN3mfSX;lChZ&3+f^ zicCho;0cpuUJzX3Wc~)hjNlPLzl-@x1aB?o@Cm_(1YZz*QIN)nX2A`Do(Uh*Y{jc zx+b~n+*i5}xxegw)IC&ipy1|$FBD8DY%d&xm2nwX>r=7v#~DOX5O_l|S{(O>n}xF< z=Mx(4<{9wM4#=`^cH=3MLZm5zS1y6nD~=-?(OZr$0Lgh2cwNz9o#@sg4nH9H=c2p7 zId6>LMpQqB`G>un>X=}4G4qxD%yN#MC%B^WT^P2mk~z^zmcK%9N2PAZlaQ4T;3p~z zfVWk8fcICH1HUbJN>cqo?yGeu%QGSQ937P3LJdF&)X4O z19W1X>aDh@As;(&zClp(8-tCx$1{G3U4tuE$$tI_}#QARI#N=$M5Vn^1om zT@2Lmo~Z}nO@cjmBSWXnK#jKH>3GCWjlKoc;lt)3{B59458_UzM&AMIc+O@4@C4@P z?@W28s&RVQahYSkPw)dr`sCf>i~V6?7N$7Ccb!^MYlCq+LO8I?bns3oW;Q7SGvnFVB87%sCt$$?HA?PdzJ^FBjMD5!LxTjdt;a(&#w`dI0XMYh_MN zyTzqxcj5b8_e0u03m(B2B8yuR-2?IHg;duc-Cnag*4L0o_NHpO<8cZ%E^BByjo;Ll zjwbO=MN?C6WOKARmP%7+G8$bKi*5^TPe=Pwu|!|$v^04Uxm2Bl{ZR^S?~n9#>!@o9lcdZhJk9K!CE56dYEzA6$Qh)Q3`RwoS`-ZBtR$GRe^;Y#E7w3>yo^^>!(DHu!j zCsL7(@hEL&z3bPjF1)@8HE0EcP2u+Dy0xu!Eg_53xwbu&N7i+Ab~G(r*%?CT;QlX( zo7?K^I-7DzLTf^t$`S~#4RZ!ft-;V5i`CrJy1Z>wr~^4=g+k4!+)&UWIhXa}_E3FO zLsO2~T-UKIlxJ(WrLMU-k8XpZd1SaTq@u%3mt<{em%b!+uMCH{VMmpxE*P{-%a+h0 zRRQX{yQw4EACGiJo4W8;emI(L+Zs*ABZJc8vT+2tmPl$#w3~v-$TqNh6I-LSESi>7 zd}RmG)VC>t9@Rfc%LZcI)Dlf@j#7O*(WgXNq=UPNl}`FHa%3G6&g!X84D_KRSz2?{ z(k(KKIC(a>G`cy~2a`6V3wFzuA;fNrE#2H4jlfP0wXnfZ$>I8eWGazVC1g6>li1dZ zaon|qbu&lBu|4SC4ek%xoSO3ux;!Y@bQl+)}^YP!-1lt(%|Mt@%{9gD=_2rzj2QMstAc8u=y z@K|c=6NX|h9Z09qv~7Ljl~j#LFkfC6Qb(3tFtM$VlwWJ>kM=1;+N7NdRIoMMkrl!7Lvt|HVZ}AHb%cUVolULF zh8b`y9ieb|X)4U7>@RJw?tE^2>g&N3)a`y zwbr+_!%y=ffvFbw!(obDxkZIL+d8m>7>?_(CXQ^%Ae=mgyVBHH7jExpYloM{_PV7_%}t$aTk68uY(lN|9c$ZVt`Nmd;c#=?YD>kk#t)-oN4NroS&C-sx)!{sW*0$DA>&li; z2Xtg*T0^U?oUBCBYOPJnxqpflwrxafVG$In%UW(lomN_li#8GSyEgLJpq^N7oMP0| z-4%pK-i{4X*LLa}r0q*%>0T_~2CZvy^TwrH2-vWhHigrJa7x|VIo#G63uCnj-P!3N6&^H7 z;u#DhFBygNW+hBxI>%IQ`BzM;tcaKLHOrz{B*wZh*9aq$9NaLMVn~tdOk_u~n8I^* z6TI#AC}Qd(T|KgXusD<}ZFjaL#J($aa%_+p--ipEp7ax5J1?-q5WNhQiA`+i=h?)M_lQ;n#?r==$7} zJUhiUH3ip?*ue=yR-Cd93^!t3DZ2yAwg{?OQG%g0ogH=gQ4+s4oF{Ve%9f?rG&U~7 zLN=P(l1}uiUZYq%j%1ZC0=z`vwnYhe0V=$3e-wTyt`cR}chuC3rQ1d`@!2e46>ttIm0z3k~K^NPm%U8^3fsY&gD*JJ5`siY&+jGfo2PcqCK}1J@@(b( zq;*cRUM)y?Z_8_h2J|g!={n46YOQZx84P9DMV4SwYg6a?wpO*4T;Gb3HLN4l+1`O; zj!;LqqaK~ZN)hHYms+c2Io6`1XJfD0Fe1R)WLnvW^PlcH)^#o=yHtF0gm=U^AxlP7 z5L0kiR;?Eg^lnUG;hs#PrBc|C56b$T4_4HY$C(W-yi{&z^?bM;u z`qj9S6>e*2z~Veh)pLy1(T5i`7y+v9tMy2ZRL2Y5w6eb&<3si^?THk2y?ojz>onOU zhWjI3JdjdYxrvZErrR)w)W!{Q7Q07|DPn@%+lH%yQakcW4~h?`q~hbzO=*Jjq@-;9 zHYTu#?xmb3TaQ}I9b1gzo+ihedUc3_a#~Kg6&v8(S!#WxuPYkQua~9KO^IYwotTQ4 z$oC;p-a?EUNR|b%t>Q5{OmQ5tifzWOKQAZABYSkIRwtZzbc6D0L)7Lesp*n)2&qNo ztg;6pSPWVn&nlj*G_8q8iSopt&Ud3pKD0wCp$_Gc7gIEKCe&m?&5<30h(ken?#kEG z&l+%wljPGW&XLQA5rcI`ZZVWca%@w|vVkinM@Ze|4Kj|*?*<&7>j)f~BRD3%_lzVZ zM;IonU>P)QrlKUz(Pd(GUK!=QeG?AjB=s31IE9@1v0)NmPDeD3gP5(+T+9dtOEgAO z;em~+I#Qy3BuDge4RavBT^A46>8Nh9I9sQqWAZ9=bY!+dN5>4;?&!E&ZH|sQQ&o+Y z;@TO_&9AD_u_J0}RP=D&P_`=MoG$CXvjwH$a#5}r*cOiJ?v1h+X_KT#f9AmsQ z?jPve62{NU#~23G0cmWGu(4m9OWoV4dl0@8r@;OFTdAL=TBBGv^TBRcJc-S7KQ0vO zO!5w-dwXLdjpO_@Qe{Iu+xoh(x`80_q8OjbVs{O{1dTADKb;lq-lp>JkEx-S#-9)v zE-tsgFlALnw;ZMN+!3XClyCB=dk6$KoW{1E(b^q%z~WeMw8pv>7LF#j#=3Bdg}Xbs zHbq&Gq9K~bHkb<><=Y|stNXfXpe41LwxO3qdMU0hDc*$VZGZX55=V>d#w=$Qw{C5T zSBvGg>l~tly2;WTP4^_a3CoETb!GQ)NwvA_?@#q?!msP?kZyt6fge|T%;TChCniNxzt!zEwY*Bj}>{3dtmh}*1f z8{cQbjYZiM^ouUeMhz9>pm=>srITWz>V>ic;q=tMv5T$Gb09e57|yZ3t0#n2K_B&x zn8`OMH(A|4svo)VmWFdjw*=0mE-qC>>`89k)YOL-L{o3#Bg*7fZZ}m}tE^%;i*)e~ zKI+L$^2D>SfLgV54d18CjWJoH*oc} z=*ap+-=^5+fux+gkB-KO>W=o}M0<2pJ@)4v4emE-fw1H^F^Wg2|<#bxk+O{R~3v4C9 zo@aAkB8A(EDfrrr1DiMV%466b#e*hZBVlE!?l)vdJQo@E;GE4G@`@qV&dzwdg!0CM zl~AfG9ora-$I^KfW@)d-x{h}M>gM^dEhBEolXT_bNT_VWt)66FHRqNJ?BGU9^4%|9 zM2PEahgabK9gc0zmr`3!p6e}_2z~A8Bwd30{W!f$^y02JZto`Iv2Jyvgm0v%gU;oB zxHY7<11y+F@{)vaM5xGR$w)uunUt(3azr}{P5|MyMz#)00DIg1;rlaeRx>ZaInaqk zIA1$tAublH+cA7!XgCe$y++nGI0(mvpn+O&=!)KMtt&a9+J&>^aLBs1BZWjCkYla} zxyzZCQ0@kah8}ofzK;Ed)i-53jZ;Y=aU{T=>7 zoiAAZS7lgc5YlbLWv9G_RaPWwTsCf6^rR2s1}p5ogJx0Hnyj+_;7rfg+4aW zi+K-jwrx`fKSB}O-W3(MM?suapVsBEr^fRg>S2|15>7|mTpaG!ie8R=GHM!LI|yAp zs_KSG>zpwE2ptD9BaYO$MP~o)p?++oL$X z#O-se;cy_yB*~)7>N`^x%w0f>Pdk0PaO3**wd!dU)!~zJy3848Z*H?8)*?pQARa?& z4Z8vEMCyoc)i%rQriPMDS4?>ajP`r%vmzmEc1=>(HLpz80VJXGKy$ z>SUg+%N+)C{8D&HwU4YDNGFs#Q2osE2g75H#fOEmM=kPHPk#TD0!veLC3?H~sUaDQ z(m--AD%veAqq-a~ad{A(HX@jn%AI`F$!#X&Dcr_~3$__p-(dCx!#aJ;u8lCc zU6Jh<@QSp$2Tl=(H?r8qdRUw|Evu*SKz~109;t>{pFFC9?Q!csJl>X64a$wBybS83 zX=UFQUQ?i!tTRh0Xvb5reY`uvkNS5ajFTVg#g)d##v?j(7p0Pa_PnymZ zP3Pk6kGbH@hVEMAumGV&c*-}3?`-fFg5qD*3*uSbI!G)++FH^aHF(MwKP8d*Xd8+c zhw*+0Z-=>DS zR7uc%oObPsEl+-N)zQ{HZ4Jwxe&hGwBIo@()~%|X|H6LVblOahlOK@A)2(UGXuH3a^DQFl`_e8T{b5;b&L^aQJObpRdHpS0}D^zwUH8 zO`&`e=_~=MIZHeX4P2C{f5)&Ep$4I{SFlXcTS1ViTGRqq0AmmQG$PV z)&`xNUghL;+VBbqXXG*wV)7ygY zF6by`9RTv~l4Q)o?@xmt01E*KdnP#jHkYde)dy*p3nDI5nXAO>M`V?OhotexpHS~& z=vYs+G86$sS36J=pUdS#c)qbs+8M2f_QD%Ibb?<1z>m^0_!*WkWEeCCok1EGeFPl> z;AdFEkb!1;v|l%UutxJ{4xrAp3EmZoI_U6&chI|1%C*vMj`gn9y(__TNDwVyB8?qI z&m2H)1Vt`rN4YZxxI$Kfxss~^8lV@Mu=XWxzu~3ndDfK_BjEITI!kyc=3dqh(kHR7M)P^%jNU@dY_0BzdkfiUPv%x_EZ(h~)vl-)Ge_{Q z3>g``UV{cQbpYs&aNQg-*jeJ|8cV*fe{IL@&K=L6GugQ7o9n*fZCd%tlV5${FZ-%L zcfz&c+|ubE`uLyzwzIY+-JQDFnSQUPvf*sB+!LHJqFO0|g)8?-Ki(gLIXWY1IK)*`N~Ib! zmm+`*yy?nu4yUII;xGpPoy^K=Kpi4+NvVdP&|!tZAYNqh4)v=4g(aG8B9%(_!-l`Cl1c4U>B%eqMU|dHYS2`IttTJx!bZkv@MU`($0WU&--)MCAOjlt0B! zx$ucewV!Vn__rdxe;bZ<{1I%Huyw?n2=Vx!KZQLPB%*#f<;C{gpV%ZcAIAGr)~<*D zG%*XMISW>WCCy@u7Qhm0j{NBaVg{ns{vLVq)xQZlw-jvb_HR;;v#FdnMkTwxf0Ou( zvM8p18}29YRn#K!42`Dnvt7|{|F#}j9D!OE5tC6?Y*eG&kTbAgj`EQ44h=b-E{CH~ zeVD~v^BSyvI1n`)=+xXejSS7)5RKdrjr@P zcSw4vXXuvUZXY`DKX-d{S9a&p#q8YsOYt{n6a#v=UwVe_0Mj8?FT5#v2E7gwW55Ri zi|ZM*RSe91M5yqcGWtF7M`w$Xo-T@MZiJ6zQ*+4S0e87LUgumo!#a=BR8h zmd?9hhWmY(PW9qqJL)8}U)1bJ0RM-(Ypxrfxr?a2Aw4nMA4asX>M&?MySPBEZ_m&} z{5qR_cyK<-V~Gc@%t>xY2onQRuEn_UB$XAtE-QMSff;fFm%!&knXr5SLvt27?B0GX z7BU&Ab;BXf=U~5!8=)6|2>#+AubqY-=aBA@=E@vo$KbWIODOgZ-O8GLa6y((Wr?PX zXPF4Ef_aoLh{8{tOVu4LDPf~`3tysDDG)5h?@6Nx(IYVRc6f<@m*ph$ZkkP!669k1^ZhD;-%5`@!;1kdv$2Mgz(k%`JN5F_IJn0{R=KkQ zIm<|8yIA(`taIYcocu7p_-W0Ka4>vi_1l+vn~%2~fAZ^He|diEJWdlle;wX1;>ULq z$yhYCF1;zWE`nNF$5peAZ-+=I_cG!-+~PzEIe!=#Q`6tQ5r2;Y`DH)%aM+)vMqZEP zfG3Yi#_3iL3Cd1?zz!{N6Mfm=2>ir9qX5&l&1Y7)J7*l^ATokgb@Fpw$i7Lkp>|Z5#1agM0l$lzATrc7&s^JijgL3a}azy zN+4zFA5qq__)qGxri65V+A0@kW}nga{Z6DyUaLHvb9O=_Btg7B08?26}E z`tS3q!68!||L{(})Lk>uZTa&Qv3W6GgVK z&C(^wNZHeC^Ypr0 qC~4}@YJ3>ii=L&9692!_aen_>KL^#{>^ZUcf2-F2r|kcd8u(unYdB2+ literal 0 HcmV?d00001 diff --git a/Middleware/SharpShell/ServerManager/ServerManager.exe b/Middleware/SharpShell/ServerManager/ServerManager.exe new file mode 100644 index 0000000000000000000000000000000000000000..df0d2dcac11875cce028c71615a837443fc9717f GIT binary patch literal 172032 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

j^t%KlGE-}8YjNL((n#f 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