Обновление до версии 2.9.0

giy

2022-09-02 ca47896204482bf4a6979e3838bf7f09f61cebeb

 QtVsTools.Package/Package/Translation.cs

@@ -1,6 +1,6 @@
/****************************************************************************

**

** Copyright (C) 2016 The Qt Company Ltd.

** Copyright (C) 2022 The Qt Company Ltd.

** Contact: https://www.qt.io/licensing/

**

** This file is part of the Qt VS Tools.

@@ -26,24 +26,16 @@
**

****************************************************************************/



using Microsoft.VisualStudio;

using Microsoft.VisualStudio.Shell.Interop;

using Microsoft.VisualStudio.VCProjectEngine;

using QtVsTools.Core;

using QtVsTools.VisualStudio;

using System;

using System.Collections.Generic;

using System.Diagnostics;

using System.IO;

using System.Linq;

using System.Text;

using System.Threading;

using System.Threading.Tasks;

using System.Windows.Forms;

using Microsoft.VisualStudio.Shell;

using Microsoft.VisualStudio.VCProjectEngine;



namespace QtVsTools

{

    using static Core.HelperFunctions;

    using Core;

    using QtMsBuild;



    /// <summary>

@@ -51,16 +43,10 @@
    /// </summary>

    public static class Translation

    {

        public static void RunlRelease(VCFile vcFile)

        {

            var vcProj = vcFile.project as VCProject;

            var project = vcProj?.Object as EnvDTE.Project;

            RunTranslationTarget(BuildAction.Release,

                project, new[] { vcFile.RelativePath });

        }



        public static void RunlRelease(VCFile[] vcFiles)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            var vcProj = vcFiles.FirstOrDefault()?.project as VCProject;

            var project = vcProj?.Object as EnvDTE.Project;

            RunTranslationTarget(BuildAction.Release,

@@ -69,11 +55,14 @@


        public static void RunlRelease(EnvDTE.Project project)

        {

            ThreadHelper.ThrowIfNotOnUIThread();

            RunTranslationTarget(BuildAction.Release, project);

        }



        public static void RunlRelease(EnvDTE.Solution solution)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            if (solution == null)

                return;



@@ -83,6 +72,8 @@


        public static void RunlUpdate(VCFile vcFile)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            var vcProj = vcFile.project as VCProject;

            var project = vcProj?.Object as EnvDTE.Project;

            RunTranslationTarget(BuildAction.Update,

@@ -91,6 +82,8 @@


        public static void RunlUpdate(VCFile[] vcFiles)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            var vcProj = vcFiles.FirstOrDefault()?.project as VCProject;

            var project = vcProj?.Object as EnvDTE.Project;

            RunTranslationTarget(BuildAction.Update,

@@ -99,16 +92,19 @@


        public static void RunlUpdate(EnvDTE.Project project)

        {

            ThreadHelper.ThrowIfNotOnUIThread();

            RunTranslationTarget(BuildAction.Update, project);

        }



        enum BuildAction { Update, Release }

        internal enum BuildAction { Update, Release }



        static void RunTranslationTarget(

            BuildAction buildAction,

            EnvDTE.Project project,

            IEnumerable<string> selectedFiles = null)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            using (WaitDialog.Start(

                "Qt Visual Studio Tools", "Running translation tool...")) {



@@ -122,10 +118,9 @@
                if (qtPro.FormatVersion < Resources.qtMinFormatVersion_Settings) {

                    Messages.Print("translation: Legacy project format");

                    try {

                        Legacy_RunTranslation(buildAction, qtPro, selectedFiles);

                    } catch (Exception e) {

                        Messages.Print(

                            e.Message + "\r\n\r\nStacktrace:\r\n" + e.StackTrace);

                        Legacy.Translation.Run(buildAction, qtPro, selectedFiles);

                    } catch (Exception exception) {

                        exception.Log();

                    }

                    return;

                }

@@ -152,12 +147,15 @@
                if (selectedFiles != null)

                    properties["SelectedFiles"] = string.Join(";", selectedFiles);



                QtProjectBuild.StartBuild(project, activeConfigId, properties, new[] { target });

                QtProjectBuild.StartBuild(

                    project, project.FullName, activeConfigId, properties, new[] { target });

            }

        }



        public static void RunlUpdate(EnvDTE.Solution solution)

        {

            ThreadHelper.ThrowIfNotOnUIThread();



            if (solution == null)

                return;



@@ -165,118 +163,23 @@
                RunlUpdate(project);

        }



        static void Legacy_RunTranslation(

            BuildAction buildAction,

            QtProject qtProject,

            IEnumerable<string> tsFiles)

        {

            if (tsFiles == null) {

                tsFiles = (qtProject.VCProject

                    .GetFilesEndingWith(".ts") as IVCCollection)

                    .Cast<VCFile>()

                    .Select(vcFile => vcFile.RelativePath);

                if (tsFiles == null) {

                    Messages.Print("translation: no translation files found");

                    return;

                }

            }

            string tempFile = null;

            foreach (var file in tsFiles.Where(file => file != null))

                Legacy_RunTranslation(buildAction, qtProject, file, ref tempFile);

        }



        static void Legacy_RunTranslation(

            BuildAction buildAction,

            QtProject qtProject,

            string tsFile,

            ref string tempFile)

        {

            var qtVersion = qtProject.GetQtVersion();

            var qtInstallPath = QtVersionManager.The().GetInstallPath(qtVersion);

            if (string.IsNullOrEmpty(qtInstallPath)) {

                Messages.Print("translation: Error accessing Qt installation");

                return;

            }



            var procInfo = new ProcessStartInfo

            {

                WorkingDirectory = qtProject.ProjectDir,

                CreateNoWindow = true,

                UseShellExecute = false,

                RedirectStandardError = true,

                RedirectStandardOutput = true,

                Arguments = ""

            };

            switch (buildAction) {

            case BuildAction.Update:

                Messages.Print("\r\n--- (lupdate) file: " + tsFile);

                procInfo.FileName = Path.Combine(qtInstallPath, "bin", "lupdate.exe");

                var options = QtVSIPSettings.GetLUpdateOptions();

                if (!string.IsNullOrEmpty(options))

                    procInfo.Arguments += options + " ";

                if (tempFile == null) {

                    var inputFiles = GetProjectFiles(qtProject.Project, FilesToList.FL_HFiles)

                        .Union(GetProjectFiles(qtProject.Project, FilesToList.FL_CppFiles))

                        .Union(GetProjectFiles(qtProject.Project, FilesToList.FL_UiFiles))

                        .Union(GetProjectFiles(qtProject.Project, FilesToList.FL_QmlFiles));

                    tempFile = Path.GetTempFileName();

                    File.WriteAllLines(tempFile, inputFiles);

                }

                procInfo.Arguments += string.Format("\"@{0}\" -ts \"{1}\"", tempFile, tsFile);

                break;

            case BuildAction.Release:

                Messages.Print("\r\n--- (lrelease) file: " + tsFile);

                procInfo.FileName = Path.Combine(qtInstallPath, "bin", "lrelease.exe");

                options = QtVSIPSettings.GetLReleaseOptions();

                if (!string.IsNullOrEmpty(options))

                    procInfo.Arguments += options + " ";

                procInfo.Arguments += string.Format("\"{0}\"", tsFile);

                break;

            }

            using (var proc = Process.Start(procInfo)) {

                proc.OutputDataReceived += (object sender, DataReceivedEventArgs e) =>

                {

                    if (!string.IsNullOrEmpty(e.Data))

                        Messages.Print(e.Data);

                };

                proc.ErrorDataReceived += (object sender, DataReceivedEventArgs e) =>

                {

                    if (!string.IsNullOrEmpty(e.Data))

                        Messages.Print(e.Data);

                };

                proc.BeginOutputReadLine();

                proc.BeginErrorReadLine();

                proc.WaitForExit();

                switch (proc.ExitCode) {

                case 0:

                    Messages.Print("translation: ok");

                    break;

                default:

                    Messages.Print(string.Format("translation: ERROR {0}", proc.ExitCode));

                    break;

                }

            }

        }



        public static void CreateNewTranslationFile(EnvDTE.Project project)

        public static bool ToolsAvailable(EnvDTE.Project project)

        {

            if (project == null)

                return;

                return false;

            if (QtProject.GetPropertyValue(project, "ApplicationType") == "Linux")

                return true;



            using (var transDlg = new AddTranslationDialog(project)) {

                if (transDlg.ShowDialog() == DialogResult.OK) {

                    try {

                        var qtPro = QtProject.Create(project);

                        var file = qtPro.AddFileInFilter(Filters.TranslationFiles(),

                            transDlg.TranslationFile, true);

                        RunlUpdate(file);

                    } catch (QtVSException e) {

                        Messages.DisplayErrorMessage(e.Message);

                    } catch (System.Exception ex) {

                        Messages.DisplayErrorMessage(ex.Message);

                    }

                }

            var qtToolsPath = QtProject.GetPropertyValue(project, "QtToolsPath");

            if (string.IsNullOrEmpty(qtToolsPath)) {

                var qtVersion = QtVersionManager.The().GetProjectQtVersion(project);

                var qtInstallPath = QtVersionManager.The().GetInstallPath(qtVersion);

                if (string.IsNullOrEmpty(qtInstallPath))

                    return false;

                qtToolsPath = Path.Combine(qtInstallPath, "bin");

            }

            return File.Exists(Path.Combine(qtToolsPath, "lupdate.exe"))

                && File.Exists(Path.Combine(qtToolsPath, "lrelease.exe"));

        }

    }

}