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.
6027 Commits
9 Branches
625MB
Tree: c1be347a3d
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c1be347a3d'
${ noResults }
JUCE/extras/Introjucer/Source/Project Saving/jucer_ProjectExporter.cpp

759 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_Headers.h"

  26. #include "jucer_ProjectExporter.h"

  27. #include "jucer_ProjectSaver.h"

  28. 

  29. #include "jucer_ProjectExport_Make.h"

  30. #include "jucer_ProjectExport_MSVC.h"

  31. #include "jucer_ProjectExport_XCode.h"

  32. #include "jucer_ProjectExport_AndroidBase.h"

  33. #include "jucer_ProjectExport_AndroidStudio.h"

  34. #include "jucer_ProjectExport_AndroidAnt.h"

  35. #include "jucer_ProjectExport_CodeBlocks.h"

  36. 

  37. //==============================================================================

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

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

  40. {

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

  42.     list.add (type);

  43. }

  44. 

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

  46. {

  47.     Array<ProjectExporter::ExporterTypeInfo> types;

  48. 

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

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

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

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

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

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

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

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

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

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

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

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

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

  62. 

  63.     return types;

  64. }

  65. 

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

  67. {

  68.     ProjectExporter* exp = nullptr;

  69. 

  70.     switch (index)

  71.     {

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

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

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

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

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

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

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

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

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

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

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

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

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

  85.         default:    jassertfalse; return 0;

  86.     }

  87. 

  88.     exp->createDefaultConfigs();

  89.     exp->createDefaultModulePaths();

  90. 

  91.     return exp;

  92. }

  93. 

  94. StringArray ProjectExporter::getExporterNames()

  95. {

  96.     StringArray s;

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

  98. 

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

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

  101. 

  102.     return s;

  103. }

  104. 

  105. String ProjectExporter::getCurrentPlatformExporterName()

  106. {

  107.    #if JUCE_MAC

  108.     return XCodeProjectExporter::getNameMac();

  109.    #elif JUCE_WINDOWS

  110.     return MSVCProjectExporterVC2010::getName();

  111.    #elif JUCE_LINUX

  112.     return MakefileProjectExporter::getNameLinux();

  113.    #else

  114.     #error // huh?

  115.    #endif

  116. }

  117. 

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

  119. {

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

  121. }

  122. 

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

  124. {

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

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

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

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

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

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

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

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

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

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

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

  136. 

  137.     jassert (exp != nullptr);

  138.     return exp;

  139. }

  140. 

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

  142. {

  143.     if (project != nullptr)

  144.     {

  145.         const char* types[] =

  146.         {

  147.            #if JUCE_MAC

  148.             XCodeProjectExporter::getValueTreeTypeName (false),

  149.             XCodeProjectExporter::getValueTreeTypeName (true),

  150.            #elif JUCE_WINDOWS

  151.             MSVCProjectExporterVC2005::getValueTreeTypeName(),

  152.             MSVCProjectExporterVC2008::getValueTreeTypeName(),

  153.             MSVCProjectExporterVC2010::getValueTreeTypeName(),

  154.             MSVCProjectExporterVC2012::getValueTreeTypeName(),

  155.             MSVCProjectExporterVC2013::getValueTreeTypeName(),

  156.             MSVCProjectExporterVC2015::getValueTreeTypeName(),

  157.            #elif JUCE_LINUX

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

  159.             //MakefileProjectExporter::getValueTreeTypeName(),

  160.            #endif

  161.             AndroidStudioProjectExporter::getValueTreeTypeName(),

  162. 

  163.             nullptr

  164.         };

  165. 

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

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

  168.                 return true;

  169.     }

  170. 

  171.     return false;

  172. }

  173. 

  174. //==============================================================================

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

  176.     : xcodeIsBundle (false),

  177.       xcodeCreatePList (false),

  178.       xcodeCanUseDwarf (true),

  179.       makefileIsDLL (false),

  180.       msvcIsDLL (false),

  181.       msvcIsWindowsSubsystem (true),

  182.       settings (state),

  183.       project (p),

  184.       projectType (p.getProjectType()),

  185.       projectName (p.getTitle()),

  186.       projectFolder (p.getProjectFolder()),

  187.       modulesGroup (nullptr)

  188. {

  189. }

  190. 

  191. ProjectExporter::~ProjectExporter()

  192. {

  193. }

  194. 

  195. File ProjectExporter::getTargetFolder() const

  196. {

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

  198. }

  199. 

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

  201. {

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

  203. }

  204. 

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

  206. {

  207.     return file.hasFileExtension (cOrCppFileExtensions)

  208.         || file.hasFileExtension (asmFileExtensions);

  209. }

  210. 

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

  212. {

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

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

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

  216. 

  217.     OwnedArray<LibraryModule> modules;

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

  219. 

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

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

  222. 

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

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

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

  226. 

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

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

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

  230. 

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

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

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

  234. 

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

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

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

  238. 

  239.     {

  240.         OwnedArray<Project::Item> images;

  241.         project.findAllImageItems (images);

  242. 

  243.         StringArray choices;

  244.         Array<var> ids;

  245. 

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

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

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

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

  250. 

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

  252.         {

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

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

  255.         }

  256. 

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

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

  259. 

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

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

  262.     }

  263. 

  264.     createExporterProperties (props);

  265. 

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

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

  268. }

  269. 

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

  271. {

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

  273.                                                  parsePreprocessorDefs (getExporterPreprocessorDefsString())));

  274.     addDefaultPreprocessorDefs (defs);

  275.     return defs;

  276. }

  277. 

  278. StringPairArray ProjectExporter::getAllPreprocessorDefs() const

  279. {

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

  281.                                                  parsePreprocessorDefs (getExporterPreprocessorDefsString())));

  282.     addDefaultPreprocessorDefs (defs);

  283.     return defs;

  284. }

  285. 

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

  287. {

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

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

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

  291. }

  292. 

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

  294. {

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

  296. }

  297. 

  298. void ProjectExporter::copyMainGroupFromProject()

  299. {

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

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

  302. }

  303. 

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

  305. {

  306.     if (modulesGroup == nullptr)

  307.     {

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

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

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

  311.     }

  312. 

  313.     return *modulesGroup;

  314. }

  315. 

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

  317. {

  318.     RelativePath localPath (rebaseFromProjectFolderToBuildTarget (pathFromProjectFolder));

  319. 

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

  321. 

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

  323.         extraSearchPaths.insert (index, path);

  324. }

  325. 

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

  327. {

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

  329. 

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

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

  332. 

  333.     if (! m.isValid())

  334.     {

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

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

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

  338.     }

  339. 

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

  341. }

  342. 

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

  344. {

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

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

  347. }

  348. 

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

  350. {

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

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

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

  354. }

  355. 

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

  357. {

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

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

  360.                              RelativePath::projectFolder);

  361. 

  362.     String path (getPathForModuleString (moduleID));

  363. 

  364.     if (path.isEmpty())

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

  366. 

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

  368. }

  369. 

  370. String ProjectExporter::getLegacyModulePath() const

  371. {

  372.     return getSettingString ("juceFolder");

  373. }

  374. 

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

  376. {

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

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

  379.                                                                 .getChildFile ("modules")

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

  381. 

  382.     String oldJucePath (getLegacyModulePath());

  383. 

  384.     if (oldJucePath.isEmpty())

  385.         return RelativePath();

  386. 

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

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

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

  390. 

  391.     return p.getChildFile (moduleID);

  392. }

  393. 

  394. void ProjectExporter::updateOldModulePaths()

  395. {

  396.     String oldPath (getLegacyModulePath());

  397. 

  398.     if (oldPath.isNotEmpty())

  399.     {

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

  401.         {

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

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

  404.         }

  405. 

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

  407.     }

  408. }

  409. 

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

  411. {

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

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

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

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

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

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

  418. }

  419. 

  420. void ProjectExporter::createDefaultModulePaths()

  421. {

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

  423.     {

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

  425.         {

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

  427.             {

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

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

  430.             }

  431. 

  432.             return;

  433.         }

  434.     }

  435. 

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

  437.     {

  438.         if (exporter->canLaunchProject())

  439.         {

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

  441.             {

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

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

  444.             }

  445. 

  446.             return;

  447.         }

  448.     }

  449. 

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

  451.     {

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

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

  454.     }

  455. }

  456. 

  457. //==============================================================================

  458. ValueTree ProjectExporter::getConfigurations() const

  459. {

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

  461. }

  462. 

  463. int ProjectExporter::getNumConfigurations() const

  464. {

  465.     return getConfigurations().getNumChildren();

  466. }

  467. 

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

  469. {

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

  471. }

  472. 

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

  474. {

  475.     const ValueTree configs (getConfigurations());

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

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

  478.             return true;

  479. 

  480.     return false;

  481. }

  482. 

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

  484. {

  485.     String nameRoot (nm);

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

  487.         nameRoot = nameRoot.dropLastCharacters (1);

  488. 

  489.     nameRoot = nameRoot.trim();

  490. 

  491.     int suffix = 2;

  492.     while (hasConfigurationNamed (name))

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

  494. 

  495.     return nm;

  496. }

  497. 

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

  499. {

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

  501.                                                                           : "New Build Configuration"));

  502. 

  503.     ValueTree configs (getConfigurations());

  504. 

  505.     if (! configs.isValid())

  506.     {

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

  508.         configs = getConfigurations();

  509.     }

  510. 

  511.     ValueTree newConfig (Ids::CONFIGURATION);

  512.     if (configToCopy != nullptr)

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

  514. 

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

  516. 

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

  518. }

  519. 

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

  521. {

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

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

  524. }

  525. 

  526. void ProjectExporter::createDefaultConfigs()

  527. {

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

  529. 

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

  531.     {

  532.         addNewConfiguration (nullptr);

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

  534. 

  535.         const bool debugConfig = i == 0;

  536. 

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

  538.         config->isDebugValue() = debugConfig;

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

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

  541.     }

  542. }

  543. 

  544. Drawable* ProjectExporter::getBigIcon() const

  545. {

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

  547. }

  548. 

  549. Drawable* ProjectExporter::getSmallIcon() const

  550. {

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

  552. }

  553. 

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

  555. {

  556.     Drawable* im = nullptr;

  557. 

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

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

  560. 

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

  562.     {

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

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

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

  566.             im = im1;

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

  568.             im = im2;

  569.     }

  570.     else

  571.     {

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

  573.     }

  574. 

  575.     if (im == nullptr)

  576.         return Image();

  577. 

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

  579.         return Image();

  580. 

  581.     return rescaleImageForIcon (*im, size);

  582. }

  583. 

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

  585. {

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

  587.     {

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

  589. 

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

  591.             return im;

  592. 

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

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

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

  596.                               im.getHeight() / 2);

  597. 

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

  599.         Graphics g (newIm);

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

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

  602.         return newIm;

  603.     }

  604. 

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

  606.     Graphics g (im);

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

  608.     return im;

  609. }

  610. 

  611. 

  612. //==============================================================================

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

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

  615. {

  616. }

  617. 

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

  619. {

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

  621.         return false;

  622. 

  623.     config = exporter.getConfiguration (index);

  624.     return true;

  625. }

  626. 

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

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

  629. {

  630. }

  631. 

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

  633. {

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

  635.         return false;

  636. 

  637.     config = exporter.getConfiguration (index);

  638.     return true;

  639. }

  640. 

  641. //==============================================================================

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

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

  644. {

  645. }

  646. 

  647. ProjectExporter::BuildConfiguration::~BuildConfiguration()

  648. {

  649. }

  650. 

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

  652. {

  653.     switch (getOptimisationLevelInt())

  654.     {

  655.         case gccO0:     return "0";

  656.         case gccO1:     return "1";

  657.         case gccO2:     return "2";

  658.         case gccO3:     return "3";

  659.         case gccOs:     return "s";

  660.         case gccOfast:  return "fast";

  661.         default:        break;

  662.     }

  663. 

  664.     return "0";

  665. }

  666. 

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

  668. {

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

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

  671.                                                 "-O1 (fast)",

  672.                                                 "-O2 (faster)",

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

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

  675.                                                 nullptr };

  676. 

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

  678.                                                    gccOs,

  679.                                                    gccO1,

  680.                                                    gccO2,

  681.                                                    gccO3,

  682.                                                    gccOfast,

  683.                                                    0 };

  684. 

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

  686.                                             StringArray (optimisationLevels),

  687.                                             Array<var> (optimisationLevelValues)),

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

  689. }

  690. 

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

  692. {

  693.     if (exporter.supportsUserDefinedConfigurations())

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

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

  696. 

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

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

  699. 

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

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

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

  703. 

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

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

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

  707. 

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

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

  710. 

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

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

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

  714. 

  715.     createConfigProperties (props);

  716. 

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

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

  719. }

  720. 

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

  722. {

  723.     return mergePreprocessorDefs (project.getPreprocessorDefs(),

  724.                                   parsePreprocessorDefs (getBuildConfigPreprocessorDefsString()));

  725. }

  726. 

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

  728. {

  729.     return getSearchPathsFromString (getHeaderSearchPathString());

  730. }

  731. 

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

  733. {

  734.     return getSearchPathsFromString (getLibrarySearchPathString());

  735. }

  736. 

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

  738. {

  739.     String s;

  740.     const StringArray libraryPaths (getLibrarySearchPaths());

  741. 

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

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

  744. 

  745.     return s;

  746. }

  747. 

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

  749. {

  750.     StringArray libraries;

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

  752.     libraries.removeEmptyStrings (true);

  753. 

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

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

  756. 

  757.     return String::empty;

  758. }