Ejemplo n.º 1
0
        private static void SetTargetMachine(VCLinkerTool linker, VersionInformation versionInfo)
        {
            String qMakeLFlagsWindows = versionInfo.GetQMakeConfEntry("QMAKE_LFLAGS_WINDOWS");
            Regex rex = new Regex("/MACHINE:(\\S+)");
            Match match = rex.Match(qMakeLFlagsWindows);
            if (match.Success)
            {
                linker.TargetMachine = HelperFunctions.TranslateMachineType(match.Groups[1].Value);
            }
            else
            {
                string platformName = versionInfo.GetVSPlatformName();
                if (platformName == "Win32")
                    linker.TargetMachine = machineTypeOption.machineX86;
                else if (platformName == "x64")
                    linker.TargetMachine = machineTypeOption.machineAMD64;
                else
                    linker.TargetMachine = machineTypeOption.machineNotSet;
            }

            String subsystemOption = "";
            String linkerOptions = linker.AdditionalOptions;
            if (linkerOptions == null)
                linkerOptions = "";

            rex = new Regex("(/SUBSYSTEM:\\S+)");
            match = rex.Match(qMakeLFlagsWindows);
            if (match.Success)
                subsystemOption = match.Groups[1].Value;

            match = rex.Match(linkerOptions);
            if (match.Success)
            {
                linkerOptions = rex.Replace(linkerOptions, subsystemOption);
            }
            else
            {
                if (linkerOptions.Length > 0)
                    linkerOptions += " ";
                linkerOptions += subsystemOption;
            }
            linker.AdditionalOptions = linkerOptions;
        }
Ejemplo n.º 2
0
        public void WriteProjectBasicConfigurations(uint type, bool usePrecompiledHeader, VersionInformation vi)
        {
            ConfigurationTypes configType = ConfigurationTypes.typeApplication;
            string targetExtension = ".exe";
            string qtVersion = null;
            QtVersionManager vm = QtVersionManager.The();
            if (vi == null)
            {
                qtVersion = vm.GetDefaultVersion();
                vi = vm.GetVersionInfo(qtVersion);
            }

            switch (type & TemplateType.ProjectType)
            {
                case TemplateType.DynamicLibrary:
                    configType = ConfigurationTypes.typeDynamicLibrary;
                    targetExtension = ".dll";
                    break;
                case TemplateType.StaticLibrary:
                    configType = ConfigurationTypes.typeStaticLibrary;
                    targetExtension = ".lib";
                    break;
            }

            foreach (VCConfiguration config in (IVCCollection)vcPro.Configurations)
            {
                config.ConfigurationType = configType;
                CompilerToolWrapper compiler = CompilerToolWrapper.Create(config);
                VCLinkerTool linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");
                VCLibrarianTool librarian = (VCLibrarianTool)((IVCCollection)config.Tools).Item("VCLibrarianTool");

                // for some stupid reason you have to set this for it to be updated...
                // the default value is the same... +platform now
            #if (VS2010 || VS2012 || VS2013)
                config.OutputDirectory = "$(SolutionDir)$(Platform)\\$(Configuration)\\";
            #else
                config.OutputDirectory = "$(SolutionDir)$(PlatformName)\\$(ConfigurationName)";
            #endif

            #if ENABLE_WINCE
                // This is mainly for Visual Studio consistency compared with a smartdevice MFC project.
                config.IntermediateDirectory = config.OutputDirectory;
            #endif

                // add some common defines
                compiler.SetPreprocessorDefinitions(vi.GetQMakeConfEntry("DEFINES").Replace(" ", ","));

                if (!vi.IsStaticBuild())
                {
                    compiler.AddPreprocessorDefinition("QT_DLL");
                }

                if (linker != null)
                {
                    if (vi.IsWinCEVersion())
                    {
                        linker.SubSystem = subSystemOption.subSystemNotSet;
                        SetTargetMachine(linker, vi);
                    }
                    else
                    {
                        if ((type & TemplateType.ConsoleSystem) != 0)
                            linker.SubSystem = subSystemOption.subSystemConsole;
                        else
                            linker.SubSystem = subSystemOption.subSystemWindows;
                    }
                    linker.OutputFile = "$(OutDir)\\$(ProjectName)" + targetExtension;
                    linker.AdditionalLibraryDirectories = "$(QTDIR)\\lib";
                    if (vi.IsStaticBuild())
                    {
                        linker.AdditionalDependencies = vi.GetQMakeConfEntry("QMAKE_LIBS_CORE");
                        if ((type & TemplateType.GUISystem) != 0)
                        {
                            linker.AdditionalDependencies += " " + vi.GetQMakeConfEntry("QMAKE_LIBS_GUI");
                            if (vi.IsWinCEVersion())
                                linker.AdditionalDependencies += " qmenu_wince.res";
                        }
                    }
                }
                else
                {
                    librarian.OutputFile = "$(OutDir)\\$(ProjectName)" + targetExtension;
                    librarian.AdditionalLibraryDirectories = "$(QTDIR)\\lib";
                }

                if ((type & TemplateType.GUISystem) != 0)
                    compiler.SetAdditionalIncludeDirectories(QtVSIPSettings.GetUicDirectory(envPro) + ";");

                if ((type & TemplateType.PluginProject) != 0)
                {
                    compiler.AddPreprocessorDefinition("QT_PLUGIN");
                }

                bool isDebugConfiguration = false;
                if (config.Name.StartsWith("Release"))
                {
                    compiler.AddPreprocessorDefinition("QT_NO_DEBUG,NDEBUG");
                    compiler.SetDebugInformationFormat(debugOption.debugDisabled);
                    compiler.SetRuntimeLibrary(runtimeLibraryOption.rtMultiThreadedDLL);
                }
                else if (config.Name.StartsWith("Debug"))
                {
                    isDebugConfiguration = true;
                    compiler.SetOptimization(optimizeOption.optimizeDisabled);
                    compiler.SetDebugInformationFormat(debugOption.debugEnabled);
                    compiler.SetRuntimeLibrary(runtimeLibraryOption.rtMultiThreadedDebugDLL);
                }
                compiler.AddAdditionalIncludeDirectories(
                    ".;" + "$(QTDIR)\\include;" + QtVSIPSettings.GetMocDirectory(envPro));

                compiler.SetTreatWChar_tAsBuiltInType(true);

                if (linker != null)
                    linker.GenerateDebugInformation = isDebugConfiguration;

            #if ENABLE_WINCE
                if (vi.IsWinCEVersion())
                {
                    compiler.SetWarningLevel(warningLevelOption.warningLevel_3);
                    compiler.SetBufferSecurityCheck(isDebugConfiguration);
                    DeploymentToolWrapper deploymentTool = DeploymentToolWrapper.Create(config);
                    if (deploymentTool != null)
                    {
                        deploymentTool.AddWinCEMSVCStandardLib(isDebugConfiguration, dte);

                        string signatureFile = vi.GetSignatureFile();
                        if (signatureFile != null)
                        {
                            Object postBuildEventToolObj = ((IVCCollection)config.Tools).Item("VCPostBuildEventTool");
                            VCPostBuildEventTool postBuildEventTool = postBuildEventToolObj as VCPostBuildEventTool;
                            if (postBuildEventTool != null)
                            {
                                string cmdline = postBuildEventTool.CommandLine;
                                if (cmdline == null)
                                    cmdline = "";
                                if (cmdline.Length > 0)
                                    postBuildEventTool.CommandLine += "\n";
                                cmdline += "signtool sign /F " + signatureFile + " \"$(TargetPath)\"";
                                postBuildEventTool.CommandLine = cmdline;
                            }
                        }
                    }
                    IVCCollection tools = ((IVCCollection)config.Tools);
                    object cst = tools.Item("VCCodeSignTool");
                    if (cst != null)
                    {
                        Type t = cst.GetType();
                        object r = t.InvokeMember("ExecutionBucket",
                            System.Reflection.BindingFlags.GetProperty,
                            null, cst, null);
                        if (r != null)
                            config.ExcludeBuckets = r.ToString();
                    }
                }
            #endif

                if (usePrecompiledHeader)
                    UsePrecompiledHeaders(config);
            }
            if ((type & TemplateType.PluginProject) != 0)
                MarkAsDesignerPluginProject();
        }
Ejemplo n.º 3
0
        public void SetupConfiguration(VCConfiguration config, VersionInformation viNew)
        {
            bool isWinPlatform = (!viNew.IsWinCEVersion());

            CompilerToolWrapper compiler = CompilerToolWrapper.Create(config);
            SimpleSet ppdefs = new SimpleSet(compiler.PreprocessorDefinitions);
            ICollection newPPDefs = viNew.GetQMakeConfEntry("DEFINES").Split(new char[] { ' ', '\t' });
            compiler.SetPreprocessorDefinitions(ppdefs.Union(newPPDefs).JoinElements(','));

            #if ENABLE_WINCE
            // search prepocessor definitions for Qt modules and add deployment settings
            if (!isWinPlatform)
            {
                DeploymentToolWrapper deploymentTool = DeploymentToolWrapper.Create(config);
                if (deploymentTool != null)
                {
                    deploymentTool.Clear();
                    deploymentTool.AddWinCEMSVCStandardLib(IsDebugConfiguration(config), dte);

                    List<QtModuleInfo> availableQtModules = QtModules.Instance.GetAvailableModuleInformation();
                    foreach (string s in ppdefs.Elements)
                    {
                        foreach (QtModuleInfo moduleInfo in availableQtModules)
                        {
                            if (moduleInfo.Defines.Contains(s))
                                AddDeploySettings(deploymentTool, moduleInfo.ModuleId, config, null, viNew);
                        }
                    }
                }
            }
            #endif

            VCLinkerTool linker = (VCLinkerTool)((IVCCollection)config.Tools).Item("VCLinkerTool");
            if (linker == null)
                return;

            if (isWinPlatform)
                linker.SubSystem = subSystemOption.subSystemWindows;
            else
                linker.SubSystem = subSystemOption.subSystemNotSet;

            SetTargetMachine(linker, viNew);
        }
Ejemplo n.º 4
0
 public static void RemovePlatformDependencies(VCConfiguration config, VersionInformation viOld)
 {
     CompilerToolWrapper compiler = CompilerToolWrapper.Create(config);
     SimpleSet minuend = new SimpleSet(compiler.PreprocessorDefinitions);
     SimpleSet subtrahend = new SimpleSet(viOld.GetQMakeConfEntry("DEFINES").Split(new char[] { ' ', '\t' }));
     compiler.SetPreprocessorDefinitions(minuend.Minus(subtrahend).JoinElements(','));
 }
Ejemplo n.º 5
0
        private void okButton_Click(object sender, EventArgs e)
        {
            QtVersionManager vm = QtVersionManager.The();
            VersionInformation versionInfo = null;
            try
            {
                versionInfo = new VersionInformation(pathBox.Text);
            }
            catch (Exception exception)
            {
                if (nameBox.Text == "$(QTDIR)")
                {
                    string defaultVersion = vm.GetDefaultVersion();
                    versionInfo = vm.GetVersionInfo(defaultVersion);
                }
                else
                {
                    Messages.DisplayErrorMessage(exception.Message);
                    return;
                }
            }

            if (versionInfo.IsWinCEVersion())
            {
                // check whether we have an SDK installed for this platform
                string platformName = versionInfo.GetVSPlatformName();
                if (!HelperFunctions.IsPlatformAvailable(Connect._applicationObject, platformName))
                {
                    MessageBox.Show(SR.GetString("AddQtVersionDialog_PlatformNotFoundError", platformName),
                                    null, MessageBoxButtons.OK,
                                    MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                    return;
                }
            }

            string makefileGenerator = versionInfo.GetQMakeConfEntry("MAKEFILE_GENERATOR");
            if (makefileGenerator != "MSVC.NET" && makefileGenerator != "MSBUILD")
            {
                MessageBox.Show(SR.GetString("AddQtVersionDialog_IncorrectMakefileGenerator", makefileGenerator),
                                            null, MessageBoxButtons.OK,
                                            MessageBoxIcon.Error, MessageBoxDefaultButton.Button1);
                return;
            }
            vm.SaveVersion(nameBox.Text, pathBox.Text);
            DialogResult = DialogResult.OK;
            Close();
        }