DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
5723 Commits
9 Branches
435MB
Tree: a99d78318b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a99d78318b'
${ noResults }
JUCE/extras/Introjucer/Source/Project Saving/jucer_ProjectExporter.cpp

757 lines
31KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

  13.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  14.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  15.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

  19.    To release a closed-source product which uses JUCE, commercial licenses are

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. #include "jucer_ProjectExporter.h"

  26. #include "jucer_ProjectSaver.h"

  27. 

  28. #include "jucer_ProjectExport_Make.h"

  29. #include "jucer_ProjectExport_MSVC.h"

  30. #include "jucer_ProjectExport_XCode.h"

  31. #include "jucer_ProjectExport_Android.h"

  32. #include "jucer_ProjectExport_AndroidStudio.h"

  33. #include "jucer_ProjectExport_CodeBlocks.h"

  34. 

  35. //==============================================================================

  36. static void addType (Array<ProjectExporter::ExporterTypeInfo>& list,

  37.                      const char* name, const void* iconData, int iconDataSize)

  38. {

  39.     ProjectExporter::ExporterTypeInfo type = { name, iconData, iconDataSize };

  40.     list.add (type);

  41. }

  42. 

  43. Array<ProjectExporter::ExporterTypeInfo> ProjectExporter::getExporterTypes()

  44. {

  45.     Array<ProjectExporter::ExporterTypeInfo> types;

  46. 

  47.     addType (types, XCodeProjectExporter::getNameMac(),          BinaryData::projectIconXcode_png,          BinaryData::projectIconXcode_pngSize);

  48.     addType (types, XCodeProjectExporter::getNameiOS(),          BinaryData::projectIconXcodeIOS_png,       BinaryData::projectIconXcodeIOS_pngSize);

  49.     addType (types, MSVCProjectExporterVC2015::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  50.     addType (types, MSVCProjectExporterVC2013::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  51.     addType (types, MSVCProjectExporterVC2012::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  52.     addType (types, MSVCProjectExporterVC2010::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  53.     addType (types, MSVCProjectExporterVC2008::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  54.     addType (types, MSVCProjectExporterVC2005::getName(),        BinaryData::projectIconVisualStudio_png,   BinaryData::projectIconVisualStudio_pngSize);

  55.     addType (types, MakefileProjectExporter::getNameLinux(),     BinaryData::projectIconLinuxMakefile_png,  BinaryData::projectIconLinuxMakefile_pngSize);

  56.     addType (types, AndroidStudioProjectExporter::getName(),     BinaryData::projectIconAndroid_png,        BinaryData::projectIconAndroid_pngSize);

  57.     addType (types, AndroidAntProjectExporter::getName(),        BinaryData::projectIconAndroid_png,        BinaryData::projectIconAndroid_pngSize);

  58.     addType (types, CodeBlocksProjectExporter::getNameWindows(), BinaryData::projectIconCodeblocks_png,     BinaryData::projectIconCodeblocks_pngSize);

  59.     addType (types, CodeBlocksProjectExporter::getNameLinux(),   BinaryData::projectIconCodeblocks_png,     BinaryData::projectIconCodeblocks_pngSize);

  60. 

  61.     return types;

  62. }

  63. 

  64. ProjectExporter* ProjectExporter::createNewExporter (Project& project, const int index)

  65. {

  66.     ProjectExporter* exp = nullptr;

  67. 

  68.     switch (index)

  69.     {

  70.         case 0:     exp = new XCodeProjectExporter         (project, ValueTree (XCodeProjectExporter         ::getValueTreeTypeName (false)), false); break;

  71.         case 1:     exp = new XCodeProjectExporter         (project, ValueTree (XCodeProjectExporter         ::getValueTreeTypeName (true)), true); break;

  72.         case 2:     exp = new MSVCProjectExporterVC2015    (project, ValueTree (MSVCProjectExporterVC2015    ::getValueTreeTypeName())); break;

  73.         case 3:     exp = new MSVCProjectExporterVC2013    (project, ValueTree (MSVCProjectExporterVC2013    ::getValueTreeTypeName())); break;

  74.         case 4:     exp = new MSVCProjectExporterVC2012    (project, ValueTree (MSVCProjectExporterVC2012    ::getValueTreeTypeName())); break;

  75.         case 5:     exp = new MSVCProjectExporterVC2010    (project, ValueTree (MSVCProjectExporterVC2010    ::getValueTreeTypeName())); break;

  76.         case 6:     exp = new MSVCProjectExporterVC2008    (project, ValueTree (MSVCProjectExporterVC2008    ::getValueTreeTypeName())); break;

  77.         case 7:     exp = new MSVCProjectExporterVC2005    (project, ValueTree (MSVCProjectExporterVC2005    ::getValueTreeTypeName())); break;

  78.         case 8:     exp = new MakefileProjectExporter      (project, ValueTree (MakefileProjectExporter      ::getValueTreeTypeName())); break;

  79.         case 9:     exp = new AndroidStudioProjectExporter (project, ValueTree (AndroidStudioProjectExporter ::getValueTreeTypeName())); break;

  80.         case 10:    exp = new AndroidAntProjectExporter    (project, ValueTree (AndroidAntProjectExporter    ::getValueTreeTypeName())); break;

  81.         case 11:    exp = new CodeBlocksProjectExporter    (project, ValueTree (CodeBlocksProjectExporter    ::getValueTreeTypeName (CodeBlocksProjectExporter::windowsTarget)), CodeBlocksProjectExporter::windowsTarget); break;

  82.         case 12:    exp = new CodeBlocksProjectExporter    (project, ValueTree (CodeBlocksProjectExporter    ::getValueTreeTypeName (CodeBlocksProjectExporter::linuxTarget)),   CodeBlocksProjectExporter::linuxTarget); break;

  83.         default:    jassertfalse; return 0;

  84.     }

  85. 

  86.     exp->createDefaultConfigs();

  87.     exp->createDefaultModulePaths();

  88. 

  89.     return exp;

  90. }

  91. 

  92. StringArray ProjectExporter::getExporterNames()

  93. {

  94.     StringArray s;

  95.     Array<ExporterTypeInfo> types (getExporterTypes());

  96. 

  97.     for (int i = 0; i < types.size(); ++i)

  98.         s.add (types.getReference(i).name);

  99. 

  100.     return s;

  101. }

  102. 

  103. String ProjectExporter::getCurrentPlatformExporterName()

  104. {

  105.    #if JUCE_MAC

  106.     return XCodeProjectExporter::getNameMac();

  107.    #elif JUCE_WINDOWS

  108.     return MSVCProjectExporterVC2010::getName();

  109.    #elif JUCE_LINUX

  110.     return MakefileProjectExporter::getNameLinux();

  111.    #else

  112.     #error // huh?

  113.    #endif

  114. }

  115. 

  116. ProjectExporter* ProjectExporter::createNewExporter (Project& project, const String& name)

  117. {

  118.     return createNewExporter (project, getExporterNames().indexOf (name));

  119. }

  120. 

  121. ProjectExporter* ProjectExporter::createExporter (Project& project, const ValueTree& settings)

  122. {

  123.     ProjectExporter*       exp = MSVCProjectExporterVC2005    ::createForSettings (project, settings);

  124.     if (exp == nullptr)    exp = MSVCProjectExporterVC2008    ::createForSettings (project, settings);

  125.     if (exp == nullptr)    exp = MSVCProjectExporterVC2010    ::createForSettings (project, settings);

  126.     if (exp == nullptr)    exp = MSVCProjectExporterVC2012    ::createForSettings (project, settings);

  127.     if (exp == nullptr)    exp = MSVCProjectExporterVC2013    ::createForSettings (project, settings);

  128.     if (exp == nullptr)    exp = MSVCProjectExporterVC2015    ::createForSettings (project, settings);

  129.     if (exp == nullptr)    exp = XCodeProjectExporter         ::createForSettings (project, settings);

  130.     if (exp == nullptr)    exp = MakefileProjectExporter      ::createForSettings (project, settings);

  131.     if (exp == nullptr)    exp = AndroidStudioProjectExporter ::createForSettings (project, settings);

  132.     if (exp == nullptr)    exp = AndroidAntProjectExporter    ::createForSettings (project, settings);

  133.     if (exp == nullptr)    exp = CodeBlocksProjectExporter    ::createForSettings (project, settings);

  134. 

  135.     jassert (exp != nullptr);

  136.     return exp;

  137. }

  138. 

  139. bool ProjectExporter::canProjectBeLaunched (Project* project)

  140. {

  141.     if (project != nullptr)

  142.     {

  143.         const char* types[] =

  144.         {

  145.            #if JUCE_MAC

  146.             XCodeProjectExporter::getValueTreeTypeName (false),

  147.             XCodeProjectExporter::getValueTreeTypeName (true),

  148.            #elif JUCE_WINDOWS

  149.             MSVCProjectExporterVC2005::getValueTreeTypeName(),

  150.             MSVCProjectExporterVC2008::getValueTreeTypeName(),

  151.             MSVCProjectExporterVC2010::getValueTreeTypeName(),

  152.             MSVCProjectExporterVC2012::getValueTreeTypeName(),

  153.             MSVCProjectExporterVC2013::getValueTreeTypeName(),

  154.             MSVCProjectExporterVC2015::getValueTreeTypeName(),

  155.            #elif JUCE_LINUX

  156.             // (this doesn't currently launch.. not really sure what it would do on linux)

  157.             //MakefileProjectExporter::getValueTreeTypeName(),

  158.            #endif

  159.             AndroidStudioProjectExporter::getValueTreeTypeName(),

  160. 

  161.             nullptr

  162.         };

  163. 

  164.         for (const char** type = types; *type != nullptr; ++type)

  165.             if (project->getExporters().getChildWithName (*type).isValid())

  166.                 return true;

  167.     }

  168. 

  169.     return false;

  170. }

  171. 

  172. //==============================================================================

  173. ProjectExporter::ProjectExporter (Project& p, const ValueTree& state)

  174.     : xcodeIsBundle (false),

  175.       xcodeCreatePList (false),

  176.       xcodeCanUseDwarf (true),

  177.       makefileIsDLL (false),

  178.       msvcIsDLL (false),

  179.       msvcIsWindowsSubsystem (true),

  180.       settings (state),

  181.       project (p),

  182.       projectType (p.getProjectType()),

  183.       projectName (p.getTitle()),

  184.       projectFolder (p.getProjectFolder()),

  185.       modulesGroup (nullptr)

  186. {

  187. }

  188. 

  189. ProjectExporter::~ProjectExporter()

  190. {

  191. }

  192. 

  193. File ProjectExporter::getTargetFolder() const

  194. {

  195.     return project.resolveFilename (getTargetLocationString());

  196. }

  197. 

  198. RelativePath ProjectExporter::rebaseFromProjectFolderToBuildTarget (const RelativePath& path) const

  199. {

  200.     return path.rebased (project.getProjectFolder(), getTargetFolder(), RelativePath::buildTargetFolder);

  201. }

  202. 

  203. bool ProjectExporter::shouldFileBeCompiledByDefault (const RelativePath& file) const

  204. {

  205.     return file.hasFileExtension (cOrCppFileExtensions)

  206.         || file.hasFileExtension (asmFileExtensions);

  207. }

  208. 

  209. void ProjectExporter::createPropertyEditors (PropertyListBuilder& props)

  210. {

  211.     props.add (new TextPropertyComponent (getTargetLocationValue(), "Target Project Folder", 2048, false),

  212.                "The location of the folder in which the " + name + " project will be created. "

  213.                "This path can be absolute, but it's much more sensible to make it relative to the jucer project directory.");

  214. 

  215.     OwnedArray<LibraryModule> modules;

  216.     project.getModules().createRequiredModules (modules);

  217. 

  218.     for (int i = 0; i < modules.size(); ++i)

  219.         modules.getUnchecked(i)->createPropertyEditors (*this, props);

  220. 

  221.     props.add (new TextPropertyComponent (getExporterPreprocessorDefs(), "Extra Preprocessor Definitions", 32768, true),

  222.                "Extra preprocessor definitions. Use the form \"NAME1=value NAME2=value\", using whitespace, commas, "

  223.                "or new-lines to separate the items - to include a space or comma in a definition, precede it with a backslash.");

  224. 

  225.     props.add (new TextPropertyComponent (getExtraCompilerFlags(), "Extra compiler flags", 8192, true),

  226.                "Extra command-line flags to be passed to the compiler. This string can contain references to preprocessor definitions in the "

  227.                "form ${NAME_OF_DEFINITION}, which will be replaced with their values.");

  228. 

  229.     props.add (new TextPropertyComponent (getExtraLinkerFlags(), "Extra linker flags", 8192, true),

  230.                "Extra command-line flags to be passed to the linker. You might want to use this for adding additional libraries. "

  231.                "This string can contain references to preprocessor definitions in the form ${NAME_OF_VALUE}, which will be replaced with their values.");

  232. 

  233.     props.add (new TextPropertyComponent (getExternalLibraries(), "External libraries to link", 8192, true),

  234.                "Additional libraries to link (one per line). You should not add any platform specific decoration to these names. "

  235.                "This string can contain references to preprocessor definitions in the form ${NAME_OF_VALUE}, which will be replaced with their values.");

  236. 

  237.     {

  238.         OwnedArray<Project::Item> images;

  239.         project.findAllImageItems (images);

  240. 

  241.         StringArray choices;

  242.         Array<var> ids;

  243. 

  244.         choices.add ("<None>");

  245.         ids.add (var::null);

  246.         choices.add (String::empty);

  247.         ids.add (var::null);

  248. 

  249.         for (int i = 0; i < images.size(); ++i)

  250.         {

  251.             choices.add (images.getUnchecked(i)->getName());

  252.             ids.add (images.getUnchecked(i)->getID());

  253.         }

  254. 

  255.         props.add (new ChoicePropertyComponent (getSmallIconImageItemID(), "Icon (small)", choices, ids),

  256.                    "Sets an icon to use for the executable.");

  257. 

  258.         props.add (new ChoicePropertyComponent (getBigIconImageItemID(), "Icon (large)", choices, ids),

  259.                    "Sets an icon to use for the executable.");

  260.     }

  261. 

  262.     createExporterProperties (props);

  263. 

  264.     props.add (new TextPropertyComponent (getUserNotes(), "Notes", 32768, true),

  265.                "Extra comments: This field is not used for code or project generation, it's just a space where you can express your thoughts.");

  266. }

  267. 

  268. StringPairArray ProjectExporter::getAllPreprocessorDefs (const ProjectExporter::BuildConfiguration& config) const

  269. {

  270.     StringPairArray defs (mergePreprocessorDefs (config.getAllPreprocessorDefs(),

  271.                                                  parsePreprocessorDefs (getExporterPreprocessorDefsString())));

  272.     addDefaultPreprocessorDefs (defs);

  273.     return defs;

  274. }

  275. 

  276. StringPairArray ProjectExporter::getAllPreprocessorDefs() const

  277. {

  278.     StringPairArray defs (mergePreprocessorDefs (project.getPreprocessorDefs(),

  279.                                                  parsePreprocessorDefs (getExporterPreprocessorDefsString())));

  280.     addDefaultPreprocessorDefs (defs);

  281.     return defs;

  282. }

  283. 

  284. void ProjectExporter::addDefaultPreprocessorDefs (StringPairArray& defs) const

  285. {

  286.     defs.set (getExporterIdentifierMacro(), "1");

  287.     defs.set ("JUCE_APP_VERSION", project.getVersionString());

  288.     defs.set ("JUCE_APP_VERSION_HEX", project.getVersionAsHex());

  289. }

  290. 

  291. String ProjectExporter::replacePreprocessorTokens (const ProjectExporter::BuildConfiguration& config, const String& sourceString) const

  292. {

  293.     return replacePreprocessorDefs (getAllPreprocessorDefs (config), sourceString);

  294. }

  295. 

  296. void ProjectExporter::copyMainGroupFromProject()

  297. {

  298.     jassert (itemGroups.size() == 0);

  299.     itemGroups.add (project.getMainGroup().createCopy());

  300. }

  301. 

  302. Project::Item& ProjectExporter::getModulesGroup()

  303. {

  304.     if (modulesGroup == nullptr)

  305.     {

  306.         jassert (itemGroups.size() > 0); // must call copyMainGroupFromProject before this.

  307.         itemGroups.add (Project::Item::createGroup (project, "Juce Modules", "__modulesgroup__"));

  308.         modulesGroup = &(itemGroups.getReference (itemGroups.size() - 1));

  309.     }

  310. 

  311.     return *modulesGroup;

  312. }

  313. 

  314. void ProjectExporter::addToExtraSearchPaths (const RelativePath& pathFromProjectFolder, int index)

  315. {

  316.     RelativePath localPath (rebaseFromProjectFolderToBuildTarget (pathFromProjectFolder));

  317. 

  318.     const String path (isVisualStudio() ? localPath.toWindowsStyle() : localPath.toUnixStyle());

  319. 

  320.     if (! extraSearchPaths.contains (path))

  321.         extraSearchPaths.insert (index, path);

  322. }

  323. 

  324. Value ProjectExporter::getPathForModuleValue (const String& moduleID)

  325. {

  326.     UndoManager* um = project.getUndoManagerFor (settings);

  327. 

  328.     ValueTree paths (settings.getOrCreateChildWithName (Ids::MODULEPATHS, um));

  329.     ValueTree m (paths.getChildWithProperty (Ids::ID, moduleID));

  330. 

  331.     if (! m.isValid())

  332.     {

  333.         m = ValueTree (Ids::MODULEPATH);

  334.         m.setProperty (Ids::ID, moduleID, um);

  335.         paths.addChild (m, -1, um);

  336.     }

  337. 

  338.     return m.getPropertyAsValue (Ids::path, um);

  339. }

  340. 

  341. String ProjectExporter::getPathForModuleString (const String& moduleID) const

  342. {

  343.     return settings.getChildWithName (Ids::MODULEPATHS)

  344.                 .getChildWithProperty (Ids::ID, moduleID) [Ids::path].toString();

  345. }

  346. 

  347. void ProjectExporter::removePathForModule (const String& moduleID)

  348. {

  349.     ValueTree paths (settings.getChildWithName (Ids::MODULEPATHS));

  350.     ValueTree m (paths.getChildWithProperty (Ids::ID, moduleID));

  351.     paths.removeChild (m, project.getUndoManagerFor (settings));

  352. }

  353. 

  354. RelativePath ProjectExporter::getModuleFolderRelativeToProject (const String& moduleID) const

  355. {

  356.     if (project.getModules().shouldCopyModuleFilesLocally (moduleID).getValue())

  357.         return RelativePath (project.getRelativePathForFile (project.getLocalModuleFolder (moduleID)),

  358.                              RelativePath::projectFolder);

  359. 

  360.     String path (getPathForModuleString (moduleID));

  361. 

  362.     if (path.isEmpty())

  363.         return getLegacyModulePath (moduleID).getChildFile (moduleID);

  364. 

  365.     return RelativePath (path, RelativePath::projectFolder).getChildFile (moduleID);

  366. }

  367. 

  368. String ProjectExporter::getLegacyModulePath() const

  369. {

  370.     return getSettingString ("juceFolder");

  371. }

  372. 

  373. RelativePath ProjectExporter::getLegacyModulePath (const String& moduleID) const

  374. {

  375.     if (project.getModules().state.getChildWithProperty (Ids::ID, moduleID) ["useLocalCopy"])

  376.         return RelativePath (project.getRelativePathForFile (project.getGeneratedCodeFolder()

  377.                                                                 .getChildFile ("modules")

  378.                                                                 .getChildFile (moduleID)), RelativePath::projectFolder);

  379. 

  380.     String oldJucePath (getLegacyModulePath());

  381. 

  382.     if (oldJucePath.isEmpty())

  383.         return RelativePath();

  384. 

  385.     RelativePath p (oldJucePath, RelativePath::projectFolder);

  386.     if (p.getFileName() != "modules")

  387.         p = p.getChildFile ("modules");

  388. 

  389.     return p.getChildFile (moduleID);

  390. }

  391. 

  392. void ProjectExporter::updateOldModulePaths()

  393. {

  394.     String oldPath (getLegacyModulePath());

  395. 

  396.     if (oldPath.isNotEmpty())

  397.     {

  398.         for (int i = project.getModules().getNumModules(); --i >= 0;)

  399.         {

  400.             String modID (project.getModules().getModuleID(i));

  401.             getPathForModuleValue (modID) = getLegacyModulePath (modID).getParentDirectory().toUnixStyle();

  402.         }

  403. 

  404.         settings.removeProperty ("juceFolder", nullptr);

  405.     }

  406. }

  407. 

  408. static bool areCompatibleExporters (const ProjectExporter& p1, const ProjectExporter& p2)

  409. {

  410.     return (p1.isVisualStudio() && p2.isVisualStudio())

  411.         || (p1.isXcode() && p2.isXcode())

  412.         || (p1.isLinuxMakefile() && p2.isLinuxMakefile())

  413.         || (p1.isAndroid() && p2.isAndroid())

  414.         || (p1.isCodeBlocksWindows() && p2.isCodeBlocksWindows())

  415.         || (p1.isCodeBlocksLinux() && p2.isCodeBlocksLinux());

  416. }

  417. 

  418. void ProjectExporter::createDefaultModulePaths()

  419. {

  420.     for (Project::ExporterIterator exporter (project); exporter.next();)

  421.     {

  422.         if (areCompatibleExporters (*this, *exporter))

  423.         {

  424.             for (int i = project.getModules().getNumModules(); --i >= 0;)

  425.             {

  426.                 String modID (project.getModules().getModuleID(i));

  427.                 getPathForModuleValue (modID) = exporter->getPathForModuleValue (modID).getValue();

  428.             }

  429. 

  430.             return;

  431.         }

  432.     }

  433. 

  434.     for (Project::ExporterIterator exporter (project); exporter.next();)

  435.     {

  436.         if (exporter->canLaunchProject())

  437.         {

  438.             for (int i = project.getModules().getNumModules(); --i >= 0;)

  439.             {

  440.                 String modID (project.getModules().getModuleID(i));

  441.                 getPathForModuleValue (modID) = exporter->getPathForModuleValue (modID).getValue();

  442.             }

  443. 

  444.             return;

  445.         }

  446.     }

  447. 

  448.     for (int i = project.getModules().getNumModules(); --i >= 0;)

  449.     {

  450.         String modID (project.getModules().getModuleID(i));

  451.         getPathForModuleValue (modID) = "../../juce";

  452.     }

  453. }

  454. 

  455. //==============================================================================

  456. ValueTree ProjectExporter::getConfigurations() const

  457. {

  458.     return settings.getChildWithName (Ids::CONFIGURATIONS);

  459. }

  460. 

  461. int ProjectExporter::getNumConfigurations() const

  462. {

  463.     return getConfigurations().getNumChildren();

  464. }

  465. 

  466. ProjectExporter::BuildConfiguration::Ptr ProjectExporter::getConfiguration (int index) const

  467. {

  468.     return createBuildConfig (getConfigurations().getChild (index));

  469. }

  470. 

  471. bool ProjectExporter::hasConfigurationNamed (const String& nameToFind) const

  472. {

  473.     const ValueTree configs (getConfigurations());

  474.     for (int i = configs.getNumChildren(); --i >= 0;)

  475.         if (configs.getChild(i) [Ids::name].toString() == nameToFind)

  476.             return true;

  477. 

  478.     return false;

  479. }

  480. 

  481. String ProjectExporter::getUniqueConfigName (String nm) const

  482. {

  483.     String nameRoot (nm);

  484.     while (CharacterFunctions::isDigit (nameRoot.getLastCharacter()))

  485.         nameRoot = nameRoot.dropLastCharacters (1);

  486. 

  487.     nameRoot = nameRoot.trim();

  488. 

  489.     int suffix = 2;

  490.     while (hasConfigurationNamed (name))

  491.         nm = nameRoot + " " + String (suffix++);

  492. 

  493.     return nm;

  494. }

  495. 

  496. void ProjectExporter::addNewConfiguration (const BuildConfiguration* configToCopy)

  497. {

  498.     const String configName (getUniqueConfigName (configToCopy != nullptr ? configToCopy->config [Ids::name].toString()

  499.                                                                           : "New Build Configuration"));

  500. 

  501.     ValueTree configs (getConfigurations());

  502. 

  503.     if (! configs.isValid())

  504.     {

  505.         settings.addChild (ValueTree (Ids::CONFIGURATIONS), 0, project.getUndoManagerFor (settings));

  506.         configs = getConfigurations();

  507.     }

  508. 

  509.     ValueTree newConfig (Ids::CONFIGURATION);

  510.     if (configToCopy != nullptr)

  511.         newConfig = configToCopy->config.createCopy();

  512. 

  513.     newConfig.setProperty (Ids::name, configName, 0);

  514. 

  515.     configs.addChild (newConfig, -1, project.getUndoManagerFor (configs));

  516. }

  517. 

  518. void ProjectExporter::BuildConfiguration::removeFromExporter()

  519. {

  520.     ValueTree configs (config.getParent());

  521.     configs.removeChild (config, project.getUndoManagerFor (configs));

  522. }

  523. 

  524. void ProjectExporter::createDefaultConfigs()

  525. {

  526.     settings.getOrCreateChildWithName (Ids::CONFIGURATIONS, nullptr);

  527. 

  528.     for (int i = 0; i < 2; ++i)

  529.     {

  530.         addNewConfiguration (nullptr);

  531.         BuildConfiguration::Ptr config (getConfiguration (i));

  532. 

  533.         const bool debugConfig = i == 0;

  534. 

  535.         config->getNameValue() = debugConfig ? "Debug" : "Release";

  536.         config->isDebugValue() = debugConfig;

  537.         config->getOptimisationLevel() = config->getDefaultOptimisationLevel();

  538.         config->getTargetBinaryName() = project.getProjectFilenameRoot();

  539.     }

  540. }

  541. 

  542. Drawable* ProjectExporter::getBigIcon() const

  543. {

  544.     return project.getMainGroup().findItemWithID (settings [Ids::bigIcon]).loadAsImageFile();

  545. }

  546. 

  547. Drawable* ProjectExporter::getSmallIcon() const

  548. {

  549.     return project.getMainGroup().findItemWithID (settings [Ids::smallIcon]).loadAsImageFile();

  550. }

  551. 

  552. Image ProjectExporter::getBestIconForSize (int size, bool returnNullIfNothingBigEnough) const

  553. {

  554.     Drawable* im = nullptr;

  555. 

  556.     ScopedPointer<Drawable> im1 (getSmallIcon());

  557.     ScopedPointer<Drawable> im2 (getBigIcon());

  558. 

  559.     if (im1 != nullptr && im2 != nullptr)

  560.     {

  561.         if (im1->getWidth() >= size && im2->getWidth() >= size)

  562.             im = im1->getWidth() < im2->getWidth() ? im1 : im2;

  563.         else if (im1->getWidth() >= size)

  564.             im = im1;

  565.         else if (im2->getWidth() >= size)

  566.             im = im2;

  567.     }

  568.     else

  569.     {

  570.         im = im1 != nullptr ? im1 : im2;

  571.     }

  572. 

  573.     if (im == nullptr)

  574.         return Image();

  575. 

  576.     if (returnNullIfNothingBigEnough && im->getWidth() < size && im->getHeight() < size)

  577.         return Image();

  578. 

  579.     return rescaleImageForIcon (*im, size);

  580. }

  581. 

  582. Image ProjectExporter::rescaleImageForIcon (Drawable& d, const int size)

  583. {

  584.     if (DrawableImage* drawableImage = dynamic_cast<DrawableImage*> (&d))

  585.     {

  586.         Image im = SoftwareImageType().convert (drawableImage->getImage());

  587. 

  588.         if (size == im.getWidth() && size == im.getHeight())

  589.             return im;

  590. 

  591.         // (scale it down in stages for better resampling)

  592.         while (im.getWidth() > 2 * size && im.getHeight() > 2 * size)

  593.             im = im.rescaled (im.getWidth() / 2,

  594.                               im.getHeight() / 2);

  595. 

  596.         Image newIm (Image::ARGB, size, size, true, SoftwareImageType());

  597.         Graphics g (newIm);

  598.         g.drawImageWithin (im, 0, 0, size, size,

  599.                            RectanglePlacement::centred | RectanglePlacement::onlyReduceInSize, false);

  600.         return newIm;

  601.     }

  602. 

  603.     Image im (Image::ARGB, size, size, true, SoftwareImageType());

  604.     Graphics g (im);

  605.     d.drawWithin (g, im.getBounds().toFloat(), RectanglePlacement::centred, 1.0f);

  606.     return im;

  607. }

  608. 

  609. 

  610. //==============================================================================

  611. ProjectExporter::ConfigIterator::ConfigIterator (ProjectExporter& e)

  612.     : index (-1), exporter (e)

  613. {

  614. }

  615. 

  616. bool ProjectExporter::ConfigIterator::next()

  617. {

  618.     if (++index >= exporter.getNumConfigurations())

  619.         return false;

  620. 

  621.     config = exporter.getConfiguration (index);

  622.     return true;

  623. }

  624. 

  625. ProjectExporter::ConstConfigIterator::ConstConfigIterator (const ProjectExporter& exporter_)

  626.     : index (-1), exporter (exporter_)

  627. {

  628. }

  629. 

  630. bool ProjectExporter::ConstConfigIterator::next()

  631. {

  632.     if (++index >= exporter.getNumConfigurations())

  633.         return false;

  634. 

  635.     config = exporter.getConfiguration (index);

  636.     return true;

  637. }

  638. 

  639. //==============================================================================

  640. ProjectExporter::BuildConfiguration::BuildConfiguration (Project& p, const ValueTree& configNode, const ProjectExporter& e)

  641.    : config (configNode), project (p), exporter (e)

  642. {

  643. }

  644. 

  645. ProjectExporter::BuildConfiguration::~BuildConfiguration()

  646. {

  647. }

  648. 

  649. String ProjectExporter::BuildConfiguration::getGCCOptimisationFlag() const

  650. {

  651.     switch (getOptimisationLevelInt())

  652.     {

  653.         case gccO0:     return "0";

  654.         case gccO1:     return "1";

  655.         case gccO2:     return "2";

  656.         case gccO3:     return "3";

  657.         case gccOs:     return "s";

  658.         case gccOfast:  return "fast";

  659.         default:        break;

  660.     }

  661. 

  662.     return "0";

  663. }

  664. 

  665. void ProjectExporter::BuildConfiguration::addGCCOptimisationProperty (PropertyListBuilder& props)

  666. {

  667.     static const char* optimisationLevels[] = { "-O0 (no optimisation)",

  668.                                                 "-Os (minimise code size)",

  669.                                                 "-O1 (fast)",

  670.                                                 "-O2 (faster)",

  671.                                                 "-O3 (fastest with safe optimisations)",

  672.                                                 "-Ofast (uses aggressive optimisations)",

  673.                                                 nullptr };

  674. 

  675.     static const int optimisationLevelValues[] = { gccO0,

  676.                                                    gccOs,

  677.                                                    gccO1,

  678.                                                    gccO2,

  679.                                                    gccO3,

  680.                                                    gccOfast,

  681.                                                    0 };

  682. 

  683.     props.add (new ChoicePropertyComponent (getOptimisationLevel(), "Optimisation",

  684.                                             StringArray (optimisationLevels),

  685.                                             Array<var> (optimisationLevelValues)),

  686.                "The optimisation level for this configuration");

  687. }

  688. 

  689. void ProjectExporter::BuildConfiguration::createPropertyEditors (PropertyListBuilder& props)

  690. {

  691.     if (exporter.supportsUserDefinedConfigurations())

  692.         props.add (new TextPropertyComponent (getNameValue(), "Name", 96, false),

  693.                    "The name of this configuration.");

  694. 

  695.     props.add (new BooleanPropertyComponent (isDebugValue(), "Debug mode", "Debugging enabled"),

  696.                "If enabled, this means that the configuration should be built with debug synbols.");

  697. 

  698.     props.add (new TextPropertyComponent (getTargetBinaryName(), "Binary name", 256, false),

  699.                "The filename to use for the destination binary executable file. If you don't add a suffix to this name, "

  700.                "a suitable platform-specific suffix will be added automatically.");

  701. 

  702.     props.add (new TextPropertyComponent (getTargetBinaryRelativePath(), "Binary location", 1024, false),

  703.                "The folder in which the finished binary should be placed. Leave this blank to cause the binary to be placed "

  704.                "in its default location in the build folder.");

  705. 

  706.     props.addSearchPathProperty (getHeaderSearchPathValue(), "Header search paths", "Extra header search paths.");

  707.     props.addSearchPathProperty (getLibrarySearchPathValue(), "Extra library search paths", "Extra library search paths.");

  708. 

  709.     props.add (new TextPropertyComponent (getBuildConfigPreprocessorDefs(), "Preprocessor definitions", 32768, true),

  710.                "Extra preprocessor definitions. Use the form \"NAME1=value NAME2=value\", using whitespace, commas, or "

  711.                "new-lines to separate the items - to include a space or comma in a definition, precede it with a backslash.");

  712. 

  713.     createConfigProperties (props);

  714. 

  715.     props.add (new TextPropertyComponent (getUserNotes(), "Notes", 32768, true),

  716.                "Extra comments: This field is not used for code or project generation, it's just a space where you can express your thoughts.");

  717. }

  718. 

  719. StringPairArray ProjectExporter::BuildConfiguration::getAllPreprocessorDefs() const

  720. {

  721.     return mergePreprocessorDefs (project.getPreprocessorDefs(),

  722.                                   parsePreprocessorDefs (getBuildConfigPreprocessorDefsString()));

  723. }

  724. 

  725. StringArray ProjectExporter::BuildConfiguration::getHeaderSearchPaths() const

  726. {

  727.     return getSearchPathsFromString (getHeaderSearchPathString());

  728. }

  729. 

  730. StringArray ProjectExporter::BuildConfiguration::getLibrarySearchPaths() const

  731. {

  732.     return getSearchPathsFromString (getLibrarySearchPathString());

  733. }

  734. 

  735. String ProjectExporter::BuildConfiguration::getGCCLibraryPathFlags() const

  736. {

  737.     String s;

  738.     const StringArray libraryPaths (getLibrarySearchPaths());

  739. 

  740.     for (int i = 0; i < libraryPaths.size(); ++i)

  741.         s << " -L" << escapeSpaces (libraryPaths[i]);

  742. 

  743.     return s;

  744. }

  745. 

  746. String ProjectExporter::getExternalLibraryFlags (const BuildConfiguration& config) const

  747. {

  748.     StringArray libraries;

  749.     libraries.addTokens (getExternalLibrariesString(), ";\n", "\"'");

  750.     libraries.removeEmptyStrings (true);

  751. 

  752.     if (libraries.size() != 0)

  753.         return replacePreprocessorTokens (config, "-l" + libraries.joinIntoString (" -l")).trim();

  754. 

  755.     return String::empty;

  756. }