JD2022-TU1/main/build/sharpmake/Tools/LegacyTools.cs

using System;
using System.IO;
using System.Linq;
using Sharpmake;

namespace JustDance.Tools
{
    public static class ScoringToolsList
    {
        // TODO : need to varify,.,., if we need this now,,. or change it to match the latest modifications related to scorign tools
        public static readonly Type[] ScoringToolList = {
                                                     typeof (GenerateDanceCache),
                                                     typeof (GenerateTMLCache),
                                                     typeof (GestureBuildLib),
                                                     typeof (BuildGestureGUI),
                                                     typeof (Examples_Controls),
                                                     typeof (Examples_Viewer),
                                                     typeof (PS4Studio),
                                                     typeof (Timeline),
                                                     typeof (TimelineUnitTest),
                                                     typeof (SKVPlayer),
                                                     typeof (ScoringDataBuildHelper),
                                                     typeof (ScoringTool)};

        public static bool IsAScoringTool(this Type type)
        {
            if (typeof(LegacyToolsSingleProjectSolution).IsAssignableFrom(type))
            {
                var solution = (LegacyToolsSingleProjectSolution)Activator.CreateInstance(type);
                return solution.MainProject.IsAScoringTool();
            }

            return ScoringToolList.Contains(type);
        }
    }

    /// <summary>
    /// Projects in Win32 tools are supposed to be migrated from Win32Tools to tools. 
    /// Wainting for the migration, only the tools in the following list are included in the solution (the other ones are not relevant in just dance context).
    /// </summary>
    public static class LegacyToolsList
    {
        private static readonly Type[] IncludedList = {
                                                     typeof (BundleExplorer),
                                                     typeof (EngineMonitor),
                                                     typeof (ParticleEditor),
                                                     typeof (ShaderCompiler),
                                                     typeof (SoundMonitor),
                                                     typeof (UA_AliasTools),
                                                     typeof (UA_AtlasEditor),
                                                     typeof (UA_FontFormatConvertor),
                                                     typeof (UA_RemoteServer),
                                                     typeof (CookingWorker),
                                                     typeof (Decode_Callstack_WiiU_GUI),
                                                     typeof (DanceEditor),
                                                     typeof (SceneParamsEditor),
                                                 };


        public static bool IsALegacySupportedTool(this Type type)
        {
            if (typeof(LegacyToolsSingleProjectSolution).IsAssignableFrom(type))
            {
                var solution = (LegacyToolsSingleProjectSolution)Activator.CreateInstance(type);
                return solution.MainProject.IsALegacySupportedTool();
            }

            return IncludedList.Contains(type);
        }
    }

    #region UA_EventsTracker
    [Generate]
    class UA_EventsTracker : LegacyToolsApplication
    {
        public UA_EventsTracker()
            : base(true)
        {
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterWinForms();
            conf.RegisterWpf();
            conf.RegisterWindowsFormsIntegration();

            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterEngineWrapper(target);

            conf.ReferencesByPath.Add(@"Lib\AvalonDock.dll");
            conf.ReferencesByPath.Add(@"Lib\GraphSharp.dll");
            conf.ReferencesByPath.Add(@"Lib\GraphSharp.Contracts.dll");
            conf.ReferencesByPath.Add(@"Lib\GraphSharp.Controls.dll");
            conf.ReferencesByPath.Add(@"Lib\Microsoft.Contracts.dll");
            conf.ReferencesByPath.Add(@"Lib\QuickGraph.dll");
            conf.ReferencesByPath.Add(@"Lib\WPFExtensions.dll");
        }
    }

    [Generate]
    class UA_EventsTrackerSolution : LegacyToolsSingleProjectSolution<UA_EventsTracker>
    {
        public UA_EventsTrackerSolution() { }
    }
    #endregion

    #region PluginManager
    [Generate]
    class PluginManager : LegacyToolsApplication
    {
        public PluginManager()
            : base(true)
        {
            ApplicationIcon = "idisk.ico";
            SourceRootPath = @"[project.RootPath]\[project.Name]\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterWinForms();
        }
    }

    [Generate]
    class PluginManagerSolution : LegacyToolsSingleProjectSolution<PluginManager>
    {
        public PluginManagerSolution() { }
    }
    #endregion

    

    #region UA_Configure
    [Generate]
    class UA_Configure : LegacyToolsApplication
    {
        public UA_Configure()
            : base(true)
        {
            ApplicationIcon = "configure.ico";
            SourceFilesExcludeRegex.Add(@".*\\WinFormsUI\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterWinForms();
            conf.RegisterWpf();
            conf.RegisterWindowsFormsIntegration();
        }
    }

    [Generate]
    class UA_ConfigureSolution : LegacyToolsSingleProjectSolution<UA_Configure>
    {
        public UA_ConfigureSolution() { }
    }
    #endregion

    #region ActorAnimPlayer
    [Generate]
    class ActorAnimPlayer : LegacyToolsApplication
    {
        public ActorAnimPlayer()
        {
            AssemblyName = "UA_ActorAnimPlayer";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<VinceToolbox>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class ActorAnimPlayerSolution : LegacyToolsSingleProjectSolution<ActorAnimPlayer>
    {
        public ActorAnimPlayerSolution() { }
    }
    #endregion

    #region ActorCreate
    [Generate]
    class ActorCreate : LegacyToolsApplication
    {
        public ActorCreate()
            : base(true)
        {
            ApplicationIcon = "ActorCreateIcon.ico";
            AssemblyName = "UA_ActorCreate";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class ActorCreateSolution : LegacyToolsSingleProjectSolution<ActorCreate>
    {
        public ActorCreateSolution() { }
    }
    #endregion

    #region AssetCookerFriendly
    [Generate]
    class AssetCookerFriendly : LegacyToolsApplication
    {
        public AssetCookerFriendly()
        {
            SourceRootPath = @"[project.RootPath]\AssetCookerFriendly\[project.Name]\";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.SolutionFolder = "apps/engine";
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<CookingWorker>(target);
            conf.AddPublicDependency<JD_Bloomberg>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class AssetCookerFriendlySolution : LegacyToolsSingleProjectSolution<AssetCookerFriendly>
    {
        public AssetCookerFriendlySolution()
        {
        }
    }
    #endregion

    #region BehaviorTreeTools
    [Generate]
    class BehaviorTreeTools : LegacyToolsApplication
    {
        public BehaviorTreeTools()
        {
            SourceFilesExcludeRegex.Add(@".*\\WinFormsUI\\.*");
            AssemblyName = "UA_BehaviorTreeTools";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<WwiseToolbox>(target);
            conf.AddPublicDependency<WinFormsUI>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class BehaviorTreeToolsSolution : LegacyToolsSingleProjectSolution<BehaviorTreeTools>
    {
        public BehaviorTreeToolsSolution() { }
    }
    #endregion



    #region CookingWorker
    [Generate]
    class CookingWorker : LegacyToolsConsoleApplication
    {
        public CookingWorker()
        {
            SourceRootPath = @"[project.RootPath]\AssetCookerFriendly\[project.Name]";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.AddPublicDependency<JD_Core>(target);
            conf.SolutionFolder = "apps/engine";
            conf.RegisterEngineWrapper(target);
            conf.TargetPath = OutputPath + @"\bin\" + conf.Name + @"\Tools\Packager\";
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class CookingWorkerSolution : LegacyToolsSingleProjectSolution<CookingWorker>
    {
        public CookingWorkerSolution()
        {
        }
    }
    #endregion

    #region CrashDumpSender
    [Generate]
    class CrashDumpSender : LegacyToolsApplication
    {
        public CrashDumpSender() { }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            //conf.AddPublicDependency<VinceToolbox>(target);
            conf.ReferencesByName.Add("Microsoft.DirectX.AudioVideoPlayback");
            conf.ReferencesByName.Add("System.Web.Services");
            conf.ReferencesByName.Add("System.DirectoryServices");
            conf.ReferencesByPath.Add(Externs.XmlRpcV2);
            conf.RegisterPerforce();
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class CrashDumpSenderSolution : LegacyToolsSingleProjectSolution<CrashDumpSender>
    {
        public CrashDumpSenderSolution() { }
    }
    #endregion

    #region CurveEditor
    [Generate]
    class CurveEditor : LegacyToolsApplication
    {
        public CurveEditor()
        {
            ApplicationIcon = "TangentMode_Linked.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterWinForms();
            conf.SolutionFolder = "framework/controls";
        }
    }

    [Generate]
    class CurveEditorSolution : LegacyToolsSingleProjectSolution<CurveEditor>
    {
        public CurveEditorSolution() { }
    }
    #endregion

    #region EngineMonitor
    [Generate]
    class EngineMonitor : LegacyToolsApplication
    {
        public EngineMonitor()
            : base(true)
        {
            ApplicationIcon = "monitor.ico";
            AssemblyName = "UA_EngineMonitor";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.AddPublicDependency<JD_Remoting>(target);
            conf.AddPublicDependency<JD_Bloomberg>(target);
            conf.ReferencesByName.Add("WindowsBase");
            conf.RegisterWinForms();
            conf.ReferencesByPath.Add(Externs.XDevKit);
        }
    }

    [Generate]
    class EngineMonitorSolution : LegacyToolsSingleProjectSolution<EngineMonitor>
    {
        public EngineMonitorSolution() { }
    }
    #endregion

    #region LinearLogFilter
    [Generate]
    class LinearLogFilter : LegacyToolsConsoleApplication
    {
        public LinearLogFilter()
            : base(true)
        {
            SourceFilesExcludeRegex.Add(@".*\\LinearLogFilterDLL\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.ReferencesByPath.Add(Externs.TargaImage);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<LinearLogFilterDLL>(target);
        }
    }

    [Generate]
    class LinearLogFilterDLL : LegacyToolsLibrary
    {
        public LinearLogFilterDLL()
        {
            SourceRootPath = @"[project.RootPath]\LinearLogFilter\[project.Name]";
        }
    }

    [Generate]
    class LinearLogFilterSolution : LegacyToolsSingleProjectSolution<LinearLogFilter>
    {
        public LinearLogFilterSolution() { }
    }
    #endregion

    #region LinkEditor
    [Generate]
    class LinkEditor : LegacyToolsApplication
    {
        public LinkEditor()
            : base(true)
        {
            AssemblyName = "UA_LinkEditor";
            ApplicationIcon = "right_arrow.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class LinkEditorSolution : LegacyToolsSingleProjectSolution<LinkEditor>
    {
        public LinkEditorSolution() { }
    }
    #endregion

    #region MemoryViewer
    [Generate]
    class MemoryViewer : LegacyToolsApplication
    {
        public MemoryViewer()
        {
            ApplicationIcon = "memoryviewer.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.RegisterEngineWrapper(target);
            conf.ReferencesByName.Add("EnvDTE");
            conf.ReferencesByName.Add("EnvDTE80");
            conf.ReferencesByName.Add("EnvDTE90");
            conf.ReferencesByName.Add("Microsoft.Office.Interop.Excel");
            conf.RegisterWinForms();
            conf.ReferencesByPath.Add(Externs.MemoryViewerSourceGrid);

            conf.AddPublicDependency<JD_Remoting>(target);
        }
    }

    [Generate]
    class MemoryViewerSolution : LegacyToolsSingleProjectSolution<MemoryViewer>
    {
        public MemoryViewerSolution() { }
    }
    #endregion

    #region PScanSharp
    [Generate]
    class PScanSharp : LegacyToolsApplication
    {
        public PScanSharp()
        {
            SourceRootPath = @"[project.RootPath]\pscansharp\pscansharpui";
            AssemblyName = "pscansharpui";
            ApplicationIcon = "PSCAN.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            (conf.Project as CSharpProject).RootNamespace = "pscansharpui";
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.ReferencesByPath.Add(Externs.TargaImage);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class PScanSharpSolution : LegacyToolsSingleProjectSolution<PScanSharp>
    {
        public PScanSharpSolution() { }
    }
    #endregion

    #region ResourceTools
    [Generate]
    class ResourceTools : LegacyToolsApplication
    {
        public ResourceTools()
        {
            ApplicationIcon = "process.ico";
            AssemblyName = "UA_ResourceTool";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.ReferencesByPath.Add(Externs.TargaImage);
            conf.RegisterPerforce();
            conf.RegisterWinForms();
            conf.SolutionFolder = "apps/engine";
        }
    }

    [Generate]
    class ResourceToolsSolution : LegacyToolsSingleProjectSolution<ResourceTools>
    {
        public ResourceToolsSolution() { }
    }
    #endregion

    #region RunOnIsc
    [Generate]
    class RunOnIsc : LegacyToolsConsoleApplication
    {
        public RunOnIsc()
            : base(true)
        {
            SourceFilesExcludeRegex.Add(@".*\\RunOnIscDLL\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<RunOnIscDLL>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class RunOnIscDLL : LegacyToolsLibrary
    {
        public RunOnIscDLL()
        {
            SourceRootPath = @"[project.RootPath]\RunOnIsc\[project.Name]";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.RegisterEngineWrapper(target);
        }
    }

    [Generate]
    class RunOnIscSolution : LegacyToolsSingleProjectSolution<RunOnIsc>
    {
        public RunOnIscSolution() { }
    }
    #endregion

    #region SequenceEditor
    [Generate]
    class SequenceEditor : LegacyToolsApplication
    {
        public SequenceEditor()
        {
            ApplicationIcon = "Resources/clap128x128.ico";
            AssemblyName = "UA_SequenceEditor";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<WwiseToolbox>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class SequenceEditorSolution : LegacyToolsSingleProjectSolution<SequenceEditor>
    {
        public SequenceEditorSolution() { }
    }
    #endregion

    #region SerializeFileList
    [Generate]
    class SerializeFileList : LegacyToolsConsoleApplication
    {
        public SerializeFileList()
            : base(true)
        {
            SourceFilesExcludeRegex.Add(@".*\\SerializeFileListDLL\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<SerializeFileListDLL>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class SerializeFileListDLL : LegacyToolsLibrary
    {
        public SerializeFileListDLL()
        {
            SourceRootPath = @"[project.RootPath]\SerializeFileList\[project.Name]";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
        }
    }

    [Generate]
    class SerializeFileListSolution : LegacyToolsSingleProjectSolution<SerializeFileList>
    {
        public SerializeFileListSolution() { }
    }
    #endregion

    #region SerializePreload
    [Generate]
    class SerializePreload : LegacyToolsConsoleApplication
    {
        public SerializePreload()
            : base(true)
        {
            SourceFilesExcludeRegex.Add(@".*\\SerializePreloadDLL\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<SerializePreloadDLL>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class SerializePreloadDLL : LegacyToolsLibrary
    {
        public SerializePreloadDLL()
        {
            SourceRootPath = @"[project.RootPath]\SerializePreload\[project.Name]";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
        }
    }

    [Generate]
    class SerializePreloadSolution : LegacyToolsSingleProjectSolution<SerializePreload>
    {
        public SerializePreloadSolution() { }
    }
    #endregion

    #region ShaderCompiler

    [Generate]
    class ShaderCompiler : LegacyToolsApplication
    {
        public ShaderCompiler() : base(true)
        {
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.RegisterWinForms();
            conf.AddPublicDependency<JD_Bloomberg>(target);

            AdditionalContentCopyIfNewer.Add("WiiU/*");
            AdditionalContentCopyIfNewer.Add("NX/*");
            AdditionalContentCopyIfNewer.Add("NX/cygwinLib/*");
            AdditionalContentCopyIfNewer.Add("VK/*");
            AdditionalContentCopyIfNewer.Add("VK/cygwinLib/*");
        }
    }

    [Generate]
    class ShaderCompilerSolution : LegacyToolsSingleProjectSolution<ShaderCompiler>
    {
        public ShaderCompilerSolution() { }
    }
    #endregion

    #region SplineEditor
    [Generate]
    class SplineEditor : LegacyToolsApplication
    {
        public SplineEditor() : base(true) { }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<CSharpDataWrapper>(target);
            Externs.RegisterLuaInterface(conf);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class SplineEditorSolution : LegacyToolsSingleProjectSolution<SplineEditor>
    {
        public SplineEditorSolution() { }
    }
    #endregion

    #region UA_AliasTools
    [Generate]
    class UA_AliasTools : LegacyToolsApplication
    {
        public UA_AliasTools() : base(true)
        {
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            //conf.AddPublicDependency<VinceToolbox>(target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.RegisterWinForms();
            conf.AddPublicDependency<JD_Bloomberg>(target);
        }
    }

    [Generate]
    class UA_AliasToolsSolution : LegacyToolsSingleProjectSolution<UA_AliasTools>
    {
        public UA_AliasToolsSolution()
        {
        }
    }
    #endregion

    #region UA_AtlasEditor
    [Generate]
    class UA_AtlasEditor : LegacyToolsApplication
    {
        public UA_AtlasEditor()
            : base(false)
        {
            ApplicationIcon = "UA_AtlasEditor.ico";
            AddFileAssociation(".atl", "Resources/AtlFile.ico");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.AddPublicDependency<JD_Core>(target);
            conf.AddPublicDependency<JD_Perforce>(target);
            conf.AddPublicDependency<JD_Bloomberg>(target);
			conf.AddPublicDependency<JD_TeaBoxAddinSystem>(target);
            Externs.RegisterLua51(conf);
            Externs.RegisterLuaInterface(conf);
            conf.ReferencesByNuGetPackage.Add(Externs.UbisoftPerforce);

            conf.RegisterWinForms();
            conf.RegisterWpf();
            conf.RegisterWindowsFormsIntegration();
        }
    }

    [Generate]
    class UA_AtlasEditorSolution : LegacyToolsSingleProjectSolution<UA_AtlasEditor>
    {
        public UA_AtlasEditorSolution()
        {
        }
    }
    #endregion

    #region UA_BreakableEditor
    [Generate]
    class UA_BreakableEditor : LegacyToolsApplication
    {
        public UA_BreakableEditor()
            : base(true)
        {
            ApplicationIcon = "UA_BreakableEditor.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.AddPublicDependency<VinceToolbox>(target);
            conf.ReferencesByPath.Add(Externs.TargaImage);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_BreakableEditorSolution : LegacyToolsSingleProjectSolution<UA_BreakableEditor>
    {
        public UA_BreakableEditorSolution() { }
    }
    #endregion

    #region UA_Bridge
    [Generate]
    class UA_Bridge : LegacyToolsApplication
    {
        public UA_Bridge()
            : base(true)
        {
            ApplicationIcon = "UA_BRIDGE.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<NetworkCommon>(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_BridgeSolution : LegacyToolsSingleProjectSolution<UA_Bridge>
    {
        public UA_BridgeSolution() { }
    }
    #endregion

    #region UA_FilterTool
    [Generate]
    class UA_FilterTool : LegacyToolsApplication
    {
        public UA_FilterTool()
            : base(true)
        {
            ApplicationIcon = "UA_FILTER_TOOL.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<VinceToolbox>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_FilterToolSolution : LegacyToolsSingleProjectSolution<UA_FilterTool>
    {
        public UA_FilterToolSolution() { }
    }
    #endregion

    #region UA_FontFormatConvertor
    [Generate]
    class UA_FontFormatConvertor : LegacyToolsConsoleApplication
    {
        public UA_FontFormatConvertor()
            : base(true)
        {
            AdditionalContentCopyIfNewer.Add("FontGenerator/*");
            OutputType = Configuration.OutputType.DotNetConsoleApp;
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Serialization>(target);
            conf.ReferencesByNuGetPackage.Add(new NuGetDependency("CommandLineParser", "2.3.0"));
        }
    }

    [Generate]
    class UA_FontFormatConvertorSolution : LegacyToolsSingleProjectSolution<UA_FilterTool>
    {
        public UA_FontFormatConvertorSolution() { }
    }
    #endregion

    #region UA_GP3Edit
    [Generate]
    class UA_GP3Edit : LegacyToolsConsoleApplication
    {
        public UA_GP3Edit()
            : base(true)
        {
            SourceFilesExcludeRegex.Add(@".*\\UA_GP3EditDLL\\.*");
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<UA_GP3EditDLL>(target);
        }
    }

    [Generate]
    class UA_GP3EditDLL : LegacyToolsLibrary
    {
        public UA_GP3EditDLL()
        {
            SourceRootPath = @"[project.RootPath]\UA_GP3Edit\[project.Name]";
        }
    }

    [Generate]
    class UA_GP3EditSolution : LegacyToolsSingleProjectSolution<UA_GP3Edit>
    {
        public UA_GP3EditSolution() { }
    }
    #endregion

    #region UA_OnlineMulti
    [Generate]
    class UA_OnlineMulti : LegacyToolsApplication
    {
        public UA_OnlineMulti()
            : base(true)
        {
            ApplicationIcon = "UA_OnlineMulti.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<NetworkCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_OnlineMultiSolution : LegacyToolsSingleProjectSolution<UA_OnlineMulti>
    {
        public UA_OnlineMultiSolution() { }
    }
    #endregion

    #region UA_RemoteProfiler
    [Generate]
    class UA_RemoteProfiler : LegacyToolsApplication
    {
        public UA_RemoteProfiler()
            : base(true)
        {
            ApplicationIcon = "UA_Remote_Profiler.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_RemoteProfilerSolution : LegacyToolsSingleProjectSolution<UA_RemoteProfiler>
    {
        public UA_RemoteProfilerSolution() { }
    }
    #endregion

    #region UA_RemoteServer
    [Generate]
    class UA_RemoteServer : LegacyToolsApplication
    {
        public UA_RemoteServer()
            : base(true)
        {
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.Options.Add(Options.CSharp.AllowUnsafeBlocks.Enabled);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<JD_Remoting>(target);
            conf.AddPublicDependency<JD_Core>(target);
            conf.AddPublicDependency<JD_TeaBoxAddinSystem>(target);
            conf.AddPublicDependency<JD_ElasticSearch>(target);
            conf.ReferencesByNuGetPackage.Add(Externs.JetBrainsAnnotationsNuget);
            conf.ReferencesByNuGetPackage.Add(Externs.NewtonsoftJsonNuget);
            conf.ReferencesByPath.Add(Externs.ElasticSearch);
            conf.ReferencesByPath.Add(Externs.Nest);
            conf.RegisterWinForms();
            conf.ReferencesByPath.Add(Externs.XDevKit);
            conf.ReferencesByName.Add("System.DirectoryServices.AccountManagement");
        }
    }

    [Generate]
    class UA_RemoteServerSolution : LegacyToolsSingleProjectSolution<UA_RemoteServer>
    {
        public UA_RemoteServerSolution()
        {
        }
    }
    #endregion

    #region UA_TextEditor
    [Generate]
    class UA_TextEditor : LegacyToolsApplication
    {
        public UA_TextEditor()
            : base(true)
        {
            ApplicationIcon = "textEditorIcon.ico";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_TextEditorSolution : LegacyToolsSingleProjectSolution<UA_TextEditor>
    {
        public UA_TextEditorSolution() { }
    }
    #endregion

    #region UA_UncompressCapture
    [Generate]
    class UA_UncompressCapture : LegacyToolsApplication
    {
        public UA_UncompressCapture() { }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_UncompressCaptureSolution : LegacyToolsSingleProjectSolution<UA_UncompressCapture>
    {
        public UA_UncompressCaptureSolution() { }
    }
    #endregion

    #region UA_LogTool
    [Generate]
    class UA_LogTool : LegacyToolsApplication
    {
        public UA_LogTool() : base(true) { }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterEngineWrapper(target);
            conf.AddPublicDependency<NetworkCommon>(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class UA_LogToolSolution : LegacyToolsSingleProjectSolution<UA_LogTool>
    {
        public UA_LogToolSolution() { }
    }
    #endregion

    #region DecodeCallstack

    [Generate]
    class Decode_Callstack_WiiU_GUI : LegacyToolsApplication
    {
        public Decode_Callstack_WiiU_GUI()
            : base(true)
        {
            ApplicationIcon = "Decode.ico";
            AssemblyName = "Decode_Callstack_WiiU_GUI";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.AddPublicDependency<JD_Bloomberg>(target);
			conf.AddPublicDependency<JD_Core>(target);
            conf.RegisterWinForms();
        }
    }

    [Generate]
    class Decode_Callstack_WiiU_GUISolution : LegacyToolsSingleProjectSolution<Decode_Callstack_WiiU_GUI>
    {
        public Decode_Callstack_WiiU_GUISolution() { }
    }
    #endregion DecodeCallstack

    #region SceneParamsEditor

    [Generate]
    class SceneParamsEditor : LegacyToolsApplication
    {
        public SceneParamsEditor()
            : base(false)
        {}

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);

            conf.RegisterWinForms();
            conf.RegisterWpf();
            conf.RegisterWindowsFormsIntegration();

            conf.RegisterEngineWrapper(target);
            conf.RegisterBloomberg(target);
            conf.AddPublicDependency<PluginCommon>(target);
            conf.AddPublicDependency<TechnoControls>(target);
            conf.AddPublicDependency<JD_Bloomberg>(target);
            conf.SolutionFolder = "apps/legacy";
        }
    }

    [Generate]
    class SceneParamsEditorSolution : LegacyToolsSingleProjectSolution<SceneParamsEditor>
    {
        public SceneParamsEditorSolution()
        {
        }
    }

    #endregion

    [Generate]
    public class LegacyToolsSolution : CSharpSolution
    {
        public bool UseMultiProject = true;

        public LegacyToolsSolution()
        {
            AddTargets(Utilities.GetDefaultTargets());

            Name = "legacy";
        }

        [Configure()]
        public virtual void ConfigureAll(Configuration conf, Target target)
        {
            conf.SolutionFileName = string.Format("{0}.{1}", Name, target.DevEnv.GetDevEnvString());
            if (UseMultiProject)
                conf.SolutionFileName += "." + Globals.CurrentProjectName;
            conf.SolutionPath = string.Format(Path.Combine(Globals.BranchRoot + @"tools\", @"legacy"));
            conf.Solution.IsFileNameToLower = false;

            conf.RegisterProjectsOfType<LegacyToolsConsoleApplication>(target);
            conf.RegisterProjectsOfType<LegacyToolsApplication>(target);
            conf.RegisterProjectsOfType<LegacyToolsLibrary>(target);
            conf.AddProject<JD_Remoting>(target);
        }
    }

    [Generate]
    public class ScoringToolsSolution: BaseSolution
    {
        public ScoringToolsSolution()
        {
            Name = "ScoringTools";
        }

        public override void ConfigureAll(Configuration conf, Target target)
        {
            base.ConfigureAll(conf, target);
            conf.RegisterProjectsOfType<ApplicationProject>(target, IncludeInSolution);
            conf.RegisterProjectsOfType<LegacyToolsApplication>(target, type => type.IsAScoringTool());
            conf.SolutionPath = Path.Combine(ToolsPath, "apps", "ScoringTools");
        }

        private bool IncludeInSolution(Type type)
        {
            return ScoringToolsList.ScoringToolList.Contains(type);
        }
    }


}