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.
5158 Commits
9 Branches
625MB
Tree: 0e97c57322
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '0e97c57322'
${ noResults }
JUCE/extras/Introjucer/Source/ComponentEditor/jucer_JucerDocument.cpp

772 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2013 - Raw Material Software 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 "../Application/jucer_Application.h"

  27. #include "../Wizards/jucer_NewFileWizard.h"

  28. #include "jucer_JucerDocument.h"

  29. #include "jucer_ObjectTypes.h"

  30. #include "ui/jucer_JucerDocumentEditor.h"

  31. #include "ui/jucer_TestComponent.h"

  32. #include "jucer_UtilityFunctions.h"

  33. #include "documents/jucer_ComponentDocument.h"

  34. #include "documents/jucer_ButtonDocument.h"

  35. 

  36. const char* const defaultClassName = "NewComponent";

  37. const char* const defaultParentClasses = "public Component";

  38. 

  39. //==============================================================================

  40. JucerDocument::JucerDocument (SourceCodeDocument* c)

  41.     : cpp (c),

  42.       className (defaultClassName),

  43.       parentClasses (defaultParentClasses),

  44.       fixedSize (false),

  45.       initialWidth (600),

  46.       initialHeight (400),

  47.       snapGridPixels (8),

  48.       snapActive (true),

  49.       snapShown (true),

  50.       componentOverlayOpacity (0.33f)

  51. {

  52.     jassert (cpp != nullptr);

  53.     resources.setDocument (this);

  54. 

  55.     IntrojucerApp::getCommandManager().commandStatusChanged();

  56.     cpp->getCodeDocument().addListener (this);

  57.     IntrojucerApp::getApp().openDocumentManager.addListener (this);

  58. }

  59. 

  60. JucerDocument::~JucerDocument()

  61. {

  62.     IntrojucerApp::getApp().openDocumentManager.removeListener (this);

  63.     cpp->getCodeDocument().removeListener (this);

  64.     IntrojucerApp::getCommandManager().commandStatusChanged();

  65. }

  66. 

  67. //==============================================================================

  68. void JucerDocument::changed()

  69. {

  70.     sendChangeMessage();

  71.     IntrojucerApp::getCommandManager().commandStatusChanged();

  72.     startTimer (800);

  73. }

  74. 

  75. struct UserDocChangeTimer  : public Timer

  76. {

  77.     UserDocChangeTimer (JucerDocument& d) : doc (d) {}

  78.     void timerCallback() override       { doc.reloadFromDocument(); }

  79. 

  80.     JucerDocument& doc;

  81. };

  82. 

  83. bool JucerDocument::documentAboutToClose (OpenDocumentManager::Document* doc)

  84. {

  85.     return doc != cpp;

  86. }

  87. 

  88. void JucerDocument::userEditedCpp()

  89. {

  90.     if (userDocChangeTimer == nullptr)

  91.         userDocChangeTimer = new UserDocChangeTimer (*this);

  92. 

  93.     userDocChangeTimer->startTimer (500);

  94. }

  95. 

  96. void JucerDocument::beginTransaction()

  97. {

  98.     getUndoManager().beginNewTransaction();

  99. }

  100. 

  101. void JucerDocument::beginTransaction (const String& name)

  102. {

  103.     getUndoManager().beginNewTransaction (name);

  104. }

  105. 

  106. void JucerDocument::timerCallback()

  107. {

  108.     if (! Component::isMouseButtonDownAnywhere())

  109.     {

  110.         stopTimer();

  111.         beginTransaction();

  112. 

  113.         flushChangesToDocuments();

  114.     }

  115. }

  116. 

  117. void JucerDocument::codeDocumentTextInserted (const String&, int)   { userEditedCpp(); }

  118. void JucerDocument::codeDocumentTextDeleted (int, int)              { userEditedCpp(); }

  119. 

  120. bool JucerDocument::perform (UndoableAction* const action, const String& actionName)

  121. {

  122.     return undoManager.perform (action, actionName);

  123. }

  124. 

  125. void JucerDocument::refreshAllPropertyComps()

  126. {

  127.     if (ComponentLayout* l = getComponentLayout())

  128.         l->getSelectedSet().changed();

  129. 

  130.     for (int i = getNumPaintRoutines(); --i >= 0;)

  131.     {

  132.         getPaintRoutine (i)->getSelectedElements().changed();

  133.         getPaintRoutine (i)->getSelectedPoints().changed();

  134.     }

  135. }

  136. 

  137. //==============================================================================

  138. void JucerDocument::setClassName (const String& newName)

  139. {

  140.     if (newName != className

  141.          && CodeHelpers::makeValidIdentifier (newName, false, false, true).isNotEmpty())

  142.     {

  143.         className = CodeHelpers::makeValidIdentifier (newName, false, false, true);

  144.         changed();

  145.     }

  146. }

  147. 

  148. void JucerDocument::setComponentName (const String& newName)

  149. {

  150.     if (newName != componentName)

  151.     {

  152.         componentName = newName;

  153.         changed();

  154.     }

  155. }

  156. 

  157. void JucerDocument::setParentClasses (const String& classes)

  158. {

  159.     if (classes != parentClasses)

  160.     {

  161.         StringArray parentClassLines;

  162.         parentClassLines.addTokens (classes, ",", StringRef());

  163.         parentClassLines.trim();

  164.         parentClassLines.removeEmptyStrings();

  165.         parentClassLines.removeDuplicates (false);

  166. 

  167.         for (int i = parentClassLines.size(); --i >= 0;)

  168.         {

  169.             String s (parentClassLines[i]);

  170.             String type;

  171. 

  172.             if (s.startsWith ("public ")

  173.                 || s.startsWith ("protected ")

  174.                 || s.startsWith ("private "))

  175.             {

  176.                 type = s.upToFirstOccurrenceOf (" ", true, false);

  177.                 s = s.fromFirstOccurrenceOf (" ", false, false);

  178. 

  179.                 if (s.trim().isEmpty())

  180.                     type = s = String::empty;

  181.             }

  182. 

  183.             s = type + CodeHelpers::makeValidIdentifier (s.trim(), false, false, true);

  184. 

  185.             parentClassLines.set (i, s);

  186.         }

  187. 

  188.         parentClasses = parentClassLines.joinIntoString (", ");

  189.         changed();

  190.     }

  191. }

  192. 

  193. void JucerDocument::setConstructorParams (const String& newParams)

  194. {

  195.     if (constructorParams != newParams)

  196.     {

  197.         constructorParams = newParams;

  198.         changed();

  199.     }

  200. }

  201. 

  202. void JucerDocument::setVariableInitialisers (const String& newInitlialisers)

  203. {

  204.     if (variableInitialisers != newInitlialisers)

  205.     {

  206.         variableInitialisers = newInitlialisers;

  207.         changed();

  208.     }

  209. }

  210. 

  211. void JucerDocument::setFixedSize (const bool isFixed)

  212. {

  213.     if (fixedSize != isFixed)

  214.     {

  215.         fixedSize = isFixed;

  216.         changed();

  217.     }

  218. }

  219. 

  220. void JucerDocument::setInitialSize (int w, int h)

  221. {

  222.     w = jmax (1, w);

  223.     h = jmax (1, h);

  224. 

  225.     if (initialWidth != w || initialHeight != h)

  226.     {

  227.         initialWidth = w;

  228.         initialHeight = h;

  229.         changed();

  230.     }

  231. }

  232. 

  233. //==============================================================================

  234. bool JucerDocument::isSnapActive (const bool disableIfCtrlKeyDown) const noexcept

  235. {

  236.     return snapActive != (disableIfCtrlKeyDown && ModifierKeys::getCurrentModifiers().isCtrlDown());

  237. }

  238. 

  239. int JucerDocument::snapPosition (int pos) const noexcept

  240. {

  241.     if (isSnapActive (true))

  242.     {

  243.         jassert (snapGridPixels > 0);

  244.         pos = ((pos + snapGridPixels * 1024 + snapGridPixels / 2) / snapGridPixels - 1024) * snapGridPixels;

  245.     }

  246. 

  247.     return pos;

  248. }

  249. 

  250. void JucerDocument::setSnappingGrid (const int numPixels, const bool active, const bool shown)

  251. {

  252.     if (numPixels != snapGridPixels

  253.          || active != snapActive

  254.          || shown != snapShown)

  255.     {

  256.         snapGridPixels = numPixels;

  257.         snapActive = active;

  258.         snapShown = shown;

  259.         changed();

  260.     }

  261. }

  262. 

  263. void JucerDocument::setComponentOverlayOpacity (const float alpha)

  264. {

  265.     if (alpha != componentOverlayOpacity)

  266.     {

  267.         componentOverlayOpacity = alpha;

  268.         changed();

  269.     }

  270. }

  271. 

  272. //==============================================================================

  273. void JucerDocument::addMethod (const String& base, const String& returnVal, const String& method, const String& initialContent,

  274.                                StringArray& baseClasses, StringArray& returnValues, StringArray& methods, StringArray& initialContents)

  275. {

  276.     baseClasses.add (base);

  277.     returnValues.add (returnVal);

  278.     methods.add (method);

  279.     initialContents.add (initialContent);

  280. }

  281. 

  282. void JucerDocument::getOptionalMethods (StringArray& baseClasses,

  283.                                         StringArray& returnValues,

  284.                                         StringArray& methods,

  285.                                         StringArray& initialContents) const

  286. {

  287.     addMethod ("Component", "void", "visibilityChanged()", "", baseClasses, returnValues, methods, initialContents);

  288.     addMethod ("Component", "void", "moved()", "", baseClasses, returnValues, methods, initialContents);

  289.     addMethod ("Component", "void", "parentHierarchyChanged()", "", baseClasses, returnValues, methods, initialContents);

  290.     addMethod ("Component", "void", "parentSizeChanged()", "", baseClasses, returnValues, methods, initialContents);

  291.     addMethod ("Component", "void", "lookAndFeelChanged()", "", baseClasses, returnValues, methods, initialContents);

  292.     addMethod ("Component", "bool", "hitTest (int x, int y)", "return true;", baseClasses, returnValues, methods, initialContents);

  293.     addMethod ("Component", "void", "broughtToFront()", "", baseClasses, returnValues, methods, initialContents);

  294.     addMethod ("Component", "void", "filesDropped (const StringArray& filenames, int mouseX, int mouseY)", "", baseClasses, returnValues, methods, initialContents);

  295.     addMethod ("Component", "void", "handleCommandMessage (int commandId)", "", baseClasses, returnValues, methods, initialContents);

  296.     addMethod ("Component", "void", "childrenChanged()", "", baseClasses, returnValues, methods, initialContents);

  297.     addMethod ("Component", "void", "enablementChanged()", "", baseClasses, returnValues, methods, initialContents);

  298. 

  299.     addMethod ("Component", "void", "mouseMove (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  300.     addMethod ("Component", "void", "mouseEnter (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  301.     addMethod ("Component", "void", "mouseExit (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  302.     addMethod ("Component", "void", "mouseDown (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  303.     addMethod ("Component", "void", "mouseDrag (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  304.     addMethod ("Component", "void", "mouseUp (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  305.     addMethod ("Component", "void", "mouseDoubleClick (const MouseEvent& e)", "", baseClasses, returnValues, methods, initialContents);

  306.     addMethod ("Component", "void", "mouseWheelMove (const MouseEvent& e, const MouseWheelDetails& wheel)", "", baseClasses, returnValues, methods, initialContents);

  307. 

  308.     addMethod ("Component", "bool", "keyPressed (const KeyPress& key)", "return false;  // Return true if your handler uses this key event, or false to allow it to be passed-on.", baseClasses, returnValues, methods, initialContents);

  309.     addMethod ("Component", "bool", "keyStateChanged (const bool isKeyDown)", "return false;  // Return true if your handler uses this key event, or false to allow it to be passed-on.", baseClasses, returnValues, methods, initialContents);

  310.     addMethod ("Component", "void", "modifierKeysChanged (const ModifierKeys& modifiers)", "", baseClasses, returnValues, methods, initialContents);

  311. 

  312.     addMethod ("Component", "void", "focusGained (FocusChangeType cause)", "", baseClasses, returnValues, methods, initialContents);

  313.     addMethod ("Component", "void", "focusLost (FocusChangeType cause)", "", baseClasses, returnValues, methods, initialContents);

  314.     addMethod ("Component", "void", "focusOfChildComponentChanged (FocusChangeType cause)", "", baseClasses, returnValues, methods, initialContents);

  315.     addMethod ("Component", "void", "modifierKeysChanged (const ModifierKeys& modifiers)", "", baseClasses, returnValues, methods, initialContents);

  316.     addMethod ("Component", "void", "inputAttemptWhenModal()", "", baseClasses, returnValues, methods, initialContents);

  317. }

  318. 

  319. void JucerDocument::setOptionalMethodEnabled (const String& methodSignature, const bool enable)

  320. {

  321.     if (enable)

  322.         activeExtraMethods.addIfNotAlreadyThere (methodSignature);

  323.     else

  324.         activeExtraMethods.removeString (methodSignature);

  325. 

  326.     changed();

  327. }

  328. 

  329. bool JucerDocument::isOptionalMethodEnabled (const String& sig) const noexcept

  330. {

  331.     return activeExtraMethods.contains (sig);

  332. }

  333. 

  334. void JucerDocument::addExtraClassProperties (PropertyPanel&)

  335. {

  336. }

  337. 

  338. //==============================================================================

  339. const char* const JucerDocument::jucerCompXmlTag = "JUCER_COMPONENT";

  340. 

  341. XmlElement* JucerDocument::createXml() const

  342. {

  343.     XmlElement* doc = new XmlElement (jucerCompXmlTag);

  344. 

  345.     doc->setAttribute ("documentType", getTypeName());

  346.     doc->setAttribute ("className", className);

  347. 

  348.     if (templateFile.trim().isNotEmpty())

  349.         doc->setAttribute ("template", templateFile);

  350. 

  351.     doc->setAttribute ("componentName", componentName);

  352.     doc->setAttribute ("parentClasses", parentClasses);

  353.     doc->setAttribute ("constructorParams", constructorParams);

  354.     doc->setAttribute ("variableInitialisers", variableInitialisers);

  355.     doc->setAttribute ("snapPixels", snapGridPixels);

  356.     doc->setAttribute ("snapActive", snapActive);

  357.     doc->setAttribute ("snapShown", snapShown);

  358.     doc->setAttribute ("overlayOpacity", String (componentOverlayOpacity, 3));

  359.     doc->setAttribute ("fixedSize", fixedSize);

  360.     doc->setAttribute ("initialWidth", initialWidth);

  361.     doc->setAttribute ("initialHeight", initialHeight);

  362. 

  363.     if (activeExtraMethods.size() > 0)

  364.     {

  365.         XmlElement* extraMethods = new XmlElement ("METHODS");

  366.         doc->addChildElement (extraMethods);

  367. 

  368.         for (int i = 0; i < activeExtraMethods.size(); ++i)

  369.         {

  370.             XmlElement* e = new XmlElement ("METHOD");

  371.             extraMethods ->addChildElement (e);

  372.             e->setAttribute ("name", activeExtraMethods[i]);

  373.         }

  374.     }

  375. 

  376.     return doc;

  377. }

  378. 

  379. bool JucerDocument::loadFromXml (const XmlElement& xml)

  380. {

  381.     if (xml.hasTagName (jucerCompXmlTag)

  382.          && getTypeName().equalsIgnoreCase (xml.getStringAttribute ("documentType")))

  383.     {

  384.         className = xml.getStringAttribute ("className", defaultClassName);

  385.         templateFile = xml.getStringAttribute ("template", String::empty);

  386.         componentName = xml.getStringAttribute ("componentName", String::empty);

  387.         parentClasses = xml.getStringAttribute ("parentClasses", defaultParentClasses);

  388.         constructorParams = xml.getStringAttribute ("constructorParams", String::empty);

  389.         variableInitialisers = xml.getStringAttribute ("variableInitialisers", String::empty);

  390. 

  391.         fixedSize = xml.getBoolAttribute ("fixedSize", false);

  392.         initialWidth = xml.getIntAttribute ("initialWidth", 300);

  393.         initialHeight = xml.getIntAttribute ("initialHeight", 200);

  394. 

  395.         snapGridPixels = xml.getIntAttribute ("snapPixels", snapGridPixels);

  396.         snapActive = xml.getBoolAttribute ("snapActive", snapActive);

  397.         snapShown = xml.getBoolAttribute ("snapShown", snapShown);

  398. 

  399.         componentOverlayOpacity = (float) xml.getDoubleAttribute ("overlayOpacity", 0.0);

  400. 

  401.         activeExtraMethods.clear();

  402. 

  403.         if (XmlElement* const methods = xml.getChildByName ("METHODS"))

  404.             forEachXmlChildElementWithTagName (*methods, e, "METHOD")

  405.                 activeExtraMethods.addIfNotAlreadyThere (e->getStringAttribute ("name"));

  406. 

  407.         activeExtraMethods.trim();

  408.         activeExtraMethods.removeEmptyStrings();

  409. 

  410.         changed();

  411.         getUndoManager().clearUndoHistory();

  412.         return true;

  413.     }

  414. 

  415.     return false;

  416. }

  417. 

  418. 

  419. //==============================================================================

  420. void JucerDocument::fillInGeneratedCode (GeneratedCode& code) const

  421. {

  422.     code.className = className;

  423.     code.componentName = componentName;

  424.     code.parentClasses = parentClasses;

  425.     code.constructorParams = constructorParams;

  426.     code.initialisers.addLines (variableInitialisers);

  427. 

  428.     if (! componentName.isEmpty())

  429.         code.constructorCode << "setName (" + quotedString (componentName, false) + ");\n";

  430. 

  431.     // call these now, just to make sure they're the first two methods in the list.

  432.     code.getCallbackCode (String::empty, "void", "paint (Graphics& g)", false)

  433.         << "//[UserPrePaint] Add your own custom painting code here..\n//[/UserPrePaint]\n\n";

  434. 

  435.     code.getCallbackCode (String::empty, "void", "resized()", false)

  436.         << "//[UserPreResize] Add your own custom resize code here..\n//[/UserPreResize]\n\n";

  437. 

  438.     if (ComponentLayout* l = getComponentLayout())

  439.         l->fillInGeneratedCode (code);

  440. 

  441.     fillInPaintCode (code);

  442. 

  443.     ScopedPointer<XmlElement> e (createXml());

  444.     jassert (e != nullptr);

  445.     code.jucerMetadata = e->createDocument ("", false, false);

  446. 

  447.     resources.fillInGeneratedCode (code);

  448. 

  449.     code.constructorCode

  450.         << "\n//[UserPreSize]\n"

  451.            "//[/UserPreSize]\n";

  452. 

  453.     if (initialWidth > 0 || initialHeight > 0)

  454.         code.constructorCode << "\nsetSize (" << initialWidth << ", " << initialHeight << ");\n";

  455. 

  456.     code.getCallbackCode (String::empty, "void", "paint (Graphics& g)", false)

  457.         << "//[UserPaint] Add your own custom painting code here..\n//[/UserPaint]";

  458. 

  459.     code.getCallbackCode (String::empty, "void", "resized()", false)

  460.         << "//[UserResized] Add your own custom resize handling here..\n//[/UserResized]";

  461. 

  462.     // add optional methods

  463.     StringArray baseClasses, returnValues, methods, initialContents;

  464.     getOptionalMethods (baseClasses, returnValues, methods, initialContents);

  465. 

  466.     for (int i = 0; i < methods.size(); ++i)

  467.     {

  468.         if (isOptionalMethodEnabled (methods[i]))

  469.         {

  470.             String baseClassToAdd (baseClasses[i]);

  471. 

  472.             if (baseClassToAdd == "Component" || baseClassToAdd == "Button")

  473.                 baseClassToAdd.clear();

  474. 

  475.             String& s = code.getCallbackCode (baseClassToAdd, returnValues[i], methods[i], false);

  476. 

  477.             if (! s.contains ("//["))

  478.             {

  479.                 String userCommentTag ("UserCode_");

  480.                 userCommentTag += methods[i].upToFirstOccurrenceOf ("(", false, false).trim();

  481. 

  482.                 s << "\n//[" << userCommentTag << "] -- Add your code here...\n"

  483.                   << initialContents[i];

  484. 

  485.                 if (initialContents[i].isNotEmpty() && ! initialContents[i].endsWithChar ('\n'))

  486.                     s << '\n';

  487. 

  488.                 s << "//[/" << userCommentTag << "]\n";

  489.             }

  490.         }

  491.     }

  492. }

  493. 

  494. void JucerDocument::fillInPaintCode (GeneratedCode& code) const

  495. {

  496.     for (int i = 0; i < getNumPaintRoutines(); ++i)

  497.         getPaintRoutine (i)

  498.             ->fillInGeneratedCode (code, code.getCallbackCode (String::empty, "void", "paint (Graphics& g)", false));

  499. }

  500. 

  501. void JucerDocument::setTemplateFile (const String& newFile)

  502. {

  503.     if (templateFile != newFile)

  504.     {

  505.         templateFile = newFile;

  506.         changed();

  507.     }

  508. }

  509. 

  510. //==============================================================================

  511. bool JucerDocument::findTemplateFiles (String& headerContent, String& cppContent) const

  512. {

  513.     if (templateFile.isNotEmpty())

  514.     {

  515.         const File f (getCppFile().getSiblingFile (templateFile));

  516. 

  517.         const File templateCpp (f.withFileExtension (".cpp"));

  518.         const File templateH (f.withFileExtension (".h"));

  519. 

  520.         headerContent = templateH.loadFileAsString();

  521.         cppContent = templateCpp.loadFileAsString();

  522. 

  523.         if (headerContent.isNotEmpty() && cppContent.isNotEmpty())

  524.             return true;

  525.     }

  526. 

  527.     headerContent = BinaryData::jucer_ComponentTemplate_h;

  528.     cppContent    = BinaryData::jucer_ComponentTemplate_cpp;

  529.     return true;

  530. }

  531. 

  532. static String fixLineEndings (const String& s)

  533. {

  534.     StringArray lines;

  535.     lines.addLines (s);

  536. 

  537.     for (int i = 0; i < lines.size(); ++i)

  538.         lines.set (i, lines[i].trimEnd());

  539. 

  540.     while (lines.size() > 0 && lines [lines.size() - 1].trim().isEmpty())

  541.         lines.remove (lines.size() - 1);

  542. 

  543.     lines.add (String::empty);

  544. 

  545.     return lines.joinIntoString ("\r\n");

  546. }

  547. 

  548. bool JucerDocument::flushChangesToDocuments()

  549. {

  550.     String headerTemplate, cppTemplate;

  551.     if (! findTemplateFiles (headerTemplate, cppTemplate))

  552.         return false;

  553. 

  554.     GeneratedCode generated (this);

  555.     fillInGeneratedCode (generated);

  556. 

  557.     const File headerFile (getHeaderFile());

  558.     generated.includeFilesCPP.insert (0, headerFile.getFileName());

  559. 

  560.     OpenDocumentManager& odm = IntrojucerApp::getApp().openDocumentManager;

  561. 

  562.     if (SourceCodeDocument* header = dynamic_cast <SourceCodeDocument*> (odm.openFile (nullptr, getHeaderFile())))

  563.     {

  564.         String existingHeader (header->getCodeDocument().getAllContent());

  565.         String existingCpp (cpp->getCodeDocument().getAllContent());

  566. 

  567.         generated.applyToCode (headerTemplate, headerFile.getFileNameWithoutExtension(), false, existingHeader);

  568.         generated.applyToCode (cppTemplate,    headerFile.getFileNameWithoutExtension(), false, existingCpp);

  569. 

  570.         headerTemplate = fixLineEndings (headerTemplate);

  571.         cppTemplate    = fixLineEndings (cppTemplate);

  572. 

  573.         if (header->getCodeDocument().getAllContent() != headerTemplate)

  574.             header->getCodeDocument().replaceAllContent (headerTemplate);

  575. 

  576.         if (cpp->getCodeDocument().getAllContent() != cppTemplate)

  577.             cpp->getCodeDocument().replaceAllContent (cppTemplate);

  578.     }

  579. 

  580.     userDocChangeTimer = nullptr;

  581.     return true;

  582. }

  583. 

  584. bool JucerDocument::reloadFromDocument()

  585. {

  586.     const String cppContent (cpp->getCodeDocument().getAllContent());

  587. 

  588.     ScopedPointer<XmlElement> newXML (pullMetaDataFromCppFile (cppContent));

  589. 

  590.     if (newXML == nullptr || ! newXML->hasTagName (jucerCompXmlTag))

  591.         return false;

  592. 

  593.     if (currentXML != nullptr && currentXML->isEquivalentTo (newXML, true))

  594.         return true;

  595. 

  596.     currentXML = newXML;

  597.     stopTimer();

  598. 

  599.     resources.loadFromCpp (getCppFile(), cppContent);

  600. 

  601.     return loadFromXml (*currentXML);

  602. }

  603. 

  604. XmlElement* JucerDocument::pullMetaDataFromCppFile (const String& cpp)

  605. {

  606.     StringArray lines;

  607.     lines.addLines (cpp);

  608. 

  609.     const int startLine = indexOfLineStartingWith (lines, "BEGIN_JUCER_METADATA", 0);

  610. 

  611.     if (startLine > 0)

  612.     {

  613.         const int endLine = indexOfLineStartingWith (lines, "END_JUCER_METADATA", startLine);

  614. 

  615.         if (endLine > startLine)

  616.             return XmlDocument::parse (lines.joinIntoString ("\n", startLine + 1,

  617.                                                              endLine - startLine - 1));

  618.     }

  619. 

  620.     return nullptr;

  621. }

  622. 

  623. bool JucerDocument::isValidJucerCppFile (const File& f)

  624. {

  625.     if (f.hasFileExtension (".cpp"))

  626.     {

  627.         const ScopedPointer<XmlElement> xml (pullMetaDataFromCppFile (f.loadFileAsString()));

  628.         return xml != nullptr && xml->hasTagName (jucerCompXmlTag);

  629.     }

  630. 

  631.     return false;

  632. }

  633. 

  634. static JucerDocument* createDocument (SourceCodeDocument* cpp)

  635. {

  636.     CodeDocument& codeDoc = cpp->getCodeDocument();

  637. 

  638.     ScopedPointer<XmlElement> xml (JucerDocument::pullMetaDataFromCppFile (codeDoc.getAllContent()));

  639. 

  640.     if (xml == nullptr || ! xml->hasTagName (JucerDocument::jucerCompXmlTag))

  641.         return nullptr;

  642. 

  643.     const String docType (xml->getStringAttribute ("documentType"));

  644. 

  645.     ScopedPointer<JucerDocument> newDoc;

  646. 

  647.     if (docType.equalsIgnoreCase ("Button"))

  648.         newDoc = new ButtonDocument (cpp);

  649. 

  650.     if (docType.equalsIgnoreCase ("Component") || docType.isEmpty())

  651.         newDoc = new ComponentDocument (cpp);

  652. 

  653.     if (newDoc != nullptr && newDoc->reloadFromDocument())

  654.         return newDoc.release();

  655. 

  656.     return nullptr;

  657. }

  658. 

  659. JucerDocument* JucerDocument::createForCppFile (Project* p, const File& file)

  660. {

  661.     OpenDocumentManager& odm = IntrojucerApp::getApp().openDocumentManager;

  662. 

  663.     if (SourceCodeDocument* cpp = dynamic_cast<SourceCodeDocument*> (odm.openFile (p, file)))

  664.         if (dynamic_cast<SourceCodeDocument*> (odm.openFile (p, file.withFileExtension (".h"))) != nullptr)

  665.             return createDocument (cpp);

  666. 

  667.     return nullptr;

  668. }

  669. 

  670. //==============================================================================

  671. class JucerComponentDocument  : public SourceCodeDocument

  672. {

  673. public:

  674.     JucerComponentDocument (Project* p, const File& f)

  675.         : SourceCodeDocument (p, f)

  676.     {

  677.     }

  678. 

  679.     bool save() override

  680.     {

  681.         return SourceCodeDocument::save() && saveHeader();

  682.     }

  683. 

  684.     bool saveHeader()

  685.     {

  686.         OpenDocumentManager& odm = IntrojucerApp::getApp().openDocumentManager;

  687. 

  688.         if (OpenDocumentManager::Document* header = odm.openFile (nullptr, getFile().withFileExtension (".h")))

  689.             return header->save();

  690. 

  691.         return false;

  692.     }

  693. 

  694.     Component* createEditor() override

  695.     {

  696.         ScopedPointer<JucerDocument> jucerDoc (JucerDocument::createForCppFile (getProject(), getFile()));

  697. 

  698.         if (jucerDoc != nullptr)

  699.             return new JucerDocumentEditor (jucerDoc.release());

  700. 

  701.         return SourceCodeDocument::createEditor();

  702.     }

  703. 

  704.     class Type  : public OpenDocumentManager::DocumentType

  705.     {

  706.     public:

  707.         Type() {}

  708. 

  709.         bool canOpenFile (const File& f) override                { return JucerDocument::isValidJucerCppFile (f); }

  710.         Document* openFile (Project* p, const File& f) override  { return new JucerComponentDocument (p, f); }

  711.     };

  712. };

  713. 

  714. OpenDocumentManager::DocumentType* createGUIDocumentType()

  715. {

  716.     return new JucerComponentDocument::Type();

  717. }

  718. 

  719. //==============================================================================

  720. class JucerFileWizard  : public NewFileWizard::Type

  721. {

  722. public:

  723.     JucerFileWizard() {}

  724. 

  725.     String getName() override  { return "GUI Component"; }

  726. 

  727.     void createNewFile (Project::Item parent) override

  728.     {

  729.         const File newFile (askUserToChooseNewFile (String (defaultClassName) + ".h", "*.h;*.cpp", parent));

  730. 

  731.         if (newFile != File::nonexistent)

  732.         {

  733.             const File headerFile (newFile.withFileExtension (".h"));

  734.             const File cppFile (newFile.withFileExtension (".cpp"));

  735. 

  736.             headerFile.replaceWithText (String::empty);

  737.             cppFile.replaceWithText (String::empty);

  738. 

  739.             OpenDocumentManager& odm = IntrojucerApp::getApp().openDocumentManager;

  740. 

  741.             if (SourceCodeDocument* cpp = dynamic_cast <SourceCodeDocument*> (odm.openFile (nullptr, cppFile)))

  742.             {

  743.                 if (SourceCodeDocument* header = dynamic_cast <SourceCodeDocument*> (odm.openFile (nullptr, headerFile)))

  744.                 {

  745.                     ScopedPointer<JucerDocument> jucerDoc (new ComponentDocument (cpp));

  746. 

  747.                     if (jucerDoc != nullptr)

  748.                     {

  749.                         jucerDoc->setClassName (newFile.getFileNameWithoutExtension());

  750. 

  751.                         jucerDoc->flushChangesToDocuments();

  752.                         jucerDoc = nullptr;

  753. 

  754.                         cpp->save();

  755.                         header->save();

  756.                         odm.closeDocument (cpp, true);

  757.                         odm.closeDocument (header, true);

  758. 

  759.                         parent.addFile (headerFile, 0, true);

  760.                         parent.addFile (cppFile, 0, true);

  761.                     }

  762.                 }

  763.             }

  764.         }

  765.     }

  766. };

  767. 

  768. NewFileWizard::Type* createGUIComponentWizard()

  769. {

  770.     return new JucerFileWizard();

  771. }