Пример #1
0
        void SetWinVersion()
        {
            int majorVer = Environment.OSVersion.Version.Major;
            int minorVer = Environment.OSVersion.Version.Minor;

            switch (majorVer)
            {
            case 5: version = WinVersions.XP; break;

            case 6:
                switch (minorVer)
                {
                case 0: version = WinVersions.Vista; break;

                case 1: version = WinVersions.Win7; break;

                case 2: version = WinVersions.Win8; break;

                case 3: version = WinVersions.Win8_1; break;

                case 4: version = WinVersions.Win10; break;

                default: throw new NotImplementedException("Версия виндоуз не поддерживается");
                }
                break;

            case 10: version = WinVersions.Win10; break;

            default: throw new NotImplementedException("Версия виндоуз не поддерживается");
            }
        }
Пример #2
0
        private string WinVersionToString(WinVersions winVersion)
        {
            switch (winVersion)
            {
            case WinVersions.v8:
                return("8");

            case WinVersions.v8_1:
                return("8.1");

            default:
                return("10");
            }
        }
Пример #3
0
        static bool GenerateAndBuildNamespace(string ns,
                                              VsVersions vsVersion, WinVersions winVersion, string winmd,
                                              string npmPackageVersion, string npmScope, string outDir, bool noDefGen, bool noBuild, bool verbose)
        {
            string moduleOutDir = Path.Combine(outDir, ns.ToLower());

            if (!Directory.Exists(moduleOutDir))
            {
                Directory.CreateDirectory(moduleOutDir);
            }

            var generator = new NodeRTProjectGenerator(winVersion, vsVersion, !noDefGen);

            Console.WriteLine("Generating code for: {0}...", ns);

            try
            {
                Reflector.GenerateProject(winmd, ns, moduleOutDir, generator, npmPackageVersion, npmScope, null);
            }
            catch (Exception e)
            {
                Console.WriteLine("Failed to generate code, error: {0}", e.Message);
                return(false);
            }

            if (!noBuild)
            {
                Console.WriteLine("Building {0}...", ns);

                try
                {
                    NodeRTProjectBuildUtils.BuildWithNodeGyp(moduleOutDir, vsVersion, verbose);
                }
                catch (IOException e)
                {
                    Console.WriteLine("IO Error occured after building the project, error: {0}", e.Message);
                    Console.WriteLine("Generated project files are located at: {0}", moduleOutDir);
                    return(false);
                }
                catch (Exception)
                {
                    Console.WriteLine("Failed to build the generated project, please try to build the project manually");
                    Console.WriteLine("Generated project files are located at: {0}", moduleOutDir);
                    return(false);
                }
                Console.WriteLine("NodeRT module generated and built successfully at: {0}", moduleOutDir);
            }
            return(true);
        }
Пример #4
0
        static bool GenerateAndBuildNamespace(string ns, 
            VsVersions vsVersion, WinVersions winVersion,string winmd,
            string npmPackageVersion, string npmScope, string outDir, bool noDefGen, bool noBuild, bool verbose)
        {
            string moduleOutDir = Path.Combine(outDir, ns.ToLower());

            if (!Directory.Exists(moduleOutDir))
            {
                Directory.CreateDirectory(moduleOutDir);
            }

            var generator = new NodeRTProjectGenerator(winVersion, vsVersion, !noDefGen);

            Console.WriteLine("Generating code for: {0}...", ns);

            try
            {
                Reflector.GenerateProject(winmd, ns, moduleOutDir, generator, npmPackageVersion, npmScope, null);
            }
            catch (Exception e)
            {
                Console.WriteLine("Failed to generate code, error: {0}", e.Message);
                return false;
            }

            if (!noBuild)
            {
                Console.WriteLine("Building {0}...", ns);

                try
                {
                    NodeRTProjectBuildUtils.BuildWithNodeGyp(moduleOutDir, vsVersion, verbose);
                }
                catch (IOException e)
                {
                    Console.WriteLine("IO Error occured after building the project, error: {0}", e.Message);
                    Console.WriteLine("Generated project files are located at: {0}", moduleOutDir);
                    return false;
                }
                catch (Exception)
                {
                    Console.WriteLine("Failed to build the generated project, please try to build the project manually");
                    Console.WriteLine("Generated project files are located at: {0}", moduleOutDir);
                    return false;
                }
                Console.WriteLine("NodeRT module generated and built successfully at: {0}", moduleOutDir);
            }
            return true;
        }
Пример #5
0
        public static bool VerifyVsAndWinVersions(WinVersions winVersion, VsVersions vsVersion, out string errorMessage)
        {
            errorMessage = null;

            if (vsVersion == VsVersions.Vs2013 && winVersion == WinVersions.v10)
            {
                errorMessage = "VS 2013 does not support building Windows 10 modules";
                return(false);
            }

            if (vsVersion == VsVersions.Vs2012 && (winVersion == WinVersions.v8_1 || winVersion == WinVersions.v10))
            {
                errorMessage = "VS 2012 only supports building Windows 8 modules";
                return(false);
            }

            return(true);
        }
Пример #6
0
        public static bool VerifyVsAndWinVersions(WinVersions winVersion, VsVersions vsVersion, out string errorMessage)
        {
            errorMessage = null;

            if (vsVersion == VsVersions.Vs2013 && winVersion == WinVersions.v10)
            {
                errorMessage = "VS 2013 does not support building Windows 10 modules";
                return false;
            }

            if (vsVersion == VsVersions.Vs2012 && (winVersion == WinVersions.v8_1 || winVersion == WinVersions.v10))
            {
                errorMessage = "VS 2012 only supports building Windows 8 modules";
                return false;
            }

            return true;
        }
Пример #7
0
 public static bool TryParseWinVersion(string winVerString, out WinVersions winVer)
 {
     switch(winVerString)
     {
         case "8":
             winVer = WinVersions.v8;
             return true;
         case "8.1":
             winVer = WinVersions.v8_1;
             return true;
         case "10":
             winVer = WinVersions.v10;
             return true;
         default:
             // set to some default value
             winVer = 0;
             return false;
     }
 }
Пример #8
0
        public static bool TryParseWinVersion(string winVerString, out WinVersions winVer)
        {
            switch (winVerString)
            {
            case "8":
                winVer = WinVersions.v8;
                return(true);

            case "8.1":
                winVer = WinVersions.v8_1;
                return(true);

            case "10":
                winVer = WinVersions.v10;
                return(true);

            default:
                // set to some default value
                winVer = 0;
                return(false);
            }
        }
Пример #9
0
        public static bool IsValidCombination(int level, string value, string parentValue)
        {
            bool isValid = true;

            switch (level)
            {
            case 1:
                VMs vm = (VMs)Enum.Parse(typeof(VMs), value);
                OSs os = (OSs)Enum.Parse(typeof(OSs), parentValue);
                isValid = VMRules[(int)os, (int)vm];
                break;

            case 3:
                WinVersions version = (WinVersions)Enum.Parse(typeof(WinVersions), value);
                Browsers    browser = (Browsers)Enum.Parse(typeof(Browsers), parentValue);
                isValid = WinVersionRules[(int)browser, (int)version];
                break;

            default:
                break;
            }
            return(isValid);
        }
Пример #10
0
 public NodeRTProjectGenerator(WinVersions winVersion, VsVersions vsVersion, bool isGenerateDef)
 {
     _winVersion    = winVersion;
     _vsVersion     = vsVersion;
     _isGenerateDef = isGenerateDef;
 }
Пример #11
0
        private void cmdGenerate_Click(object sender, EventArgs e)
        {
            // in case we have a single item just select it
            if (namespaceList.Items.Count == 1)
            {
                namespaceList.SelectedItem = namespaceList.Items[0];
            }

            if ((namespaceList.SelectedItem == null) || string.IsNullOrEmpty(txtFilename.Text))
            {
                MessageBox.Show("Please select a namespace to generate", "No namespace was chosen");
                return;
            }

            btnGenerate.Enabled = false;

            var         winMdFile      = txtFilename.Text;
            var         winRTNamespace = namespaceList.SelectedItem.ToString();
            VsVersions  vsVersion      = (VsVersions)cmbVsVersion.SelectedIndex;
            WinVersions winVersion     = (WinVersions)cmbWindowsVersion.SelectedIndex;
            string      outputFolder   = Path.Combine(txtOutputDirectory.Text, winRTNamespace.ToLower());

            string errorMessage;

            if (!NodeRTProjectGenerator.VerifyVsAndWinVersions(winVersion, vsVersion, out errorMessage))
            {
                MessageBox.Show("Unsupported Windows and VS combination:\n" + errorMessage, "Unsupported options", MessageBoxButtons.OK, MessageBoxIcon.Error);
                btnGenerate.Enabled = true;
                return;
            }

            var  generator   = new NodeRTProjectGenerator(winVersion, vsVersion, chkDefGen.Checked);
            bool buildModule = chkBuildModule.Checked;

            btnGenerate.Text = "Generating code...";
            bool succeeded = false;

            Task.Run(() =>
            {
                string modulePath;
                try
                {
                    modulePath = Reflector.GenerateProject(winMdFile, winRTNamespace, outputFolder,
                                                           generator, null, null, null);
                }
                catch (Exception ex)
                {
                    MessageBox.Show("Failed to generate project file\n" + ex.Message,
                                    "Failed to generate project file", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    throw ex;
                }

                MethodInvoker invoker = new MethodInvoker(delegate() { btnGenerate.Text = "Building..."; });
                btnGenerate.Invoke(invoker);

                if (buildModule)
                {
                    try
                    {
                        NodeRTProjectBuildUtils.BuildWithNodeGyp(modulePath, vsVersion);
                        succeeded = true;
                    }
                    catch (IOException ex)
                    {
                        MessageBox.Show("IO Error occured after building the project:\n" +
                                        ex.Message + "\n" +
                                        "You can access the project files at: " + outputFolder, "IO Error occurred", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                    catch (Exception)
                    {
                        MessageBox.Show("Failed to build the project from generated code.\n" +
                                        "Please try to build the project manually.\n" +
                                        "You can access the project files at: " + outputFolder, "Failed to build project", MessageBoxButtons.OK, MessageBoxIcon.Error);
                    }
                }
                else
                {
                    succeeded = true;
                }
            })
            .ContinueWith((t) =>
            {
                btnGenerate.Enabled = true;
                if (chkBuildModule.Checked)
                {
                    btnGenerate.Text = "Generate and build module";
                }
                else
                {
                    btnGenerate.Text = "Generate module";
                }

                if (succeeded)
                {
                    MessageBox.Show("Yay! The generated NodeRT module is located at:\n" + outputFolder, "Success");
                }
            },
                          TaskScheduler.FromCurrentSynchronizationContext());
        }
Пример #12
0
 public NodeRTProjectGenerator(WinVersions winVersion, VsVersions vsVersion, bool isGenerateDef)
 {
     _winVersion = winVersion;
     _vsVersion = vsVersion;
     _isGenerateDef = isGenerateDef;
 }
Пример #13
0
 private string WinVersionToString(WinVersions winVersion)
 {
     switch (winVersion)
     {
         case WinVersions.v8:
             return "8";
         case WinVersions.v8_1:
             return "8.1";
         default:
             return "10";
     }
 }
Пример #14
0
        static void Main(string[] args)
        {
            var argsDictionary = ParseCommandLineArgs(args);

            if (argsDictionary.ContainsKey("help"))
            {
                PrintHelp();
                return;
            }

            if (!ValidateArguments(argsDictionary))
            {
                PrintHelpAndExitWithError();
                return;
            }

            if (argsDictionary.ContainsKey("namespaces"))
            {
                PrintNamespaces(argsDictionary);
                return;
            }

            string winmd  = argsDictionary["winmd"];
            string outDir = argsDictionary["outdir"];

            bool noDefGen = argsDictionary.ContainsKey("nodefgen");
            bool noBuild  = argsDictionary.ContainsKey("nobuild");
            bool verbose  = argsDictionary.ContainsKey("verbose");

            if (!Directory.Exists(outDir))
            {
                Directory.CreateDirectory(outDir);
            }

            string ns             = ValueOrNull(argsDictionary, "namespace");
            string customWinMdDir = ValueOrNull(argsDictionary, "customwinmddir");

            VsVersions  vsVersion  = VsVersions.Vs2017;
            WinVersions winVersion = WinVersions.v10;

            if (argsDictionary.ContainsKey("vs"))
            {
                if (!Enum.TryParse <VsVersions>(argsDictionary["vs"], true, out vsVersion))
                {
                    Console.WriteLine("Unsupported VS version. Supported options are: VS2017, VS2015, VS2013, VS2012");
                    Environment.Exit(1);
                }
            }

            if (argsDictionary.ContainsKey("winver"))
            {
                if (!NodeRTProjectGenerator.TryParseWinVersion(argsDictionary["winver"], out winVersion))
                {
                    Console.WriteLine("Unssuported Windows version. Supported options are: 10, 8.1, 8");
                    Environment.Exit(1);
                }
            }

            string npmPackageVersion = null;

            if (argsDictionary.ContainsKey("npmversion"))
            {
                npmPackageVersion = argsDictionary["npmversion"];
            }

            string npmPackageScope = null;

            if (argsDictionary.ContainsKey("npmscope"))
            {
                npmPackageScope = argsDictionary["npmscope"];
            }

            String errorMessage = null;

            if (!NodeRTProjectGenerator.VerifyVsAndWinVersions(winVersion, vsVersion, out errorMessage))
            {
                Console.WriteLine("Unssuported Windows and VS versions combination.");
                Console.WriteLine(errorMessage);
                Environment.Exit(1);
            }

            // generate specific namespace
            if (!String.IsNullOrEmpty(ns))
            {
                GenerateAndBuildNamespace(ns, vsVersion, winVersion, winmd,
                                          npmPackageVersion, npmPackageScope,
                                          outDir, noDefGen, noBuild, verbose);
            }
            else // try to generate & build all namespaces in winmd file
            {
                List <String> failedList = new List <string>();
                Console.WriteLine("Started to generate and build all namespaces in given WinMD...\n");
                foreach (string winRtNamespace in Reflector.GetNamespaces(winmd, customWinMdDir))
                {
                    if (!GenerateAndBuildNamespace(winRtNamespace,
                                                   vsVersion, winVersion, winmd,
                                                   npmPackageVersion, npmPackageScope, outDir, noDefGen, noBuild, verbose))
                    {
                        failedList.Add(winRtNamespace);
                    }
                    Console.WriteLine();
                }

                if (failedList.Count > 0)
                {
                    Console.WriteLine("Failed to generate or build for the following namespaces:");
                    foreach (string winRtNamespace in failedList)
                    {
                        Console.WriteLine("\t{0}", winRtNamespace);
                    }
                }
                else
                {
                    Console.WriteLine("Finished!");
                }
            }
        }