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.
3279 Commits
9 Branches
4.5GB
Tree: eb646f8c42
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'eb646f8c42'
${ noResults }
JUCE/extras/Introjucer/Source/ComponentEditor/jucer_JucerDocument.cpp

767 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 "../Project/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.     commandManager->commandStatusChanged();

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

  57. }

  58. 

  59. JucerDocument::~JucerDocument()

  60. {

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

  62.     commandManager->commandStatusChanged();

  63. }

  64. 

  65. //==============================================================================

  66. void JucerDocument::changed()

  67. {

  68.     sendChangeMessage();

  69.     commandManager->commandStatusChanged();

  70.     startTimer (800);

  71. }

  72. 

  73. struct UserDocChangeTimer  : public Timer

  74. {

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

  76.     void timerCallback()        { doc.reloadFromDocument(); }

  77. 

  78.     JucerDocument& doc;

  79. };

  80. 

  81. void JucerDocument::userEditedCpp()

  82. {

  83.     if (userDocChangeTimer == nullptr)

  84.         userDocChangeTimer = new UserDocChangeTimer (*this);

  85. 

  86.     userDocChangeTimer->startTimer (500);

  87. }

  88. 

  89. void JucerDocument::beginTransaction()

  90. {

  91.     getUndoManager().beginNewTransaction();

  92. }

  93. 

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

  95. {

  96.     getUndoManager().beginNewTransaction (name);

  97. }

  98. 

  99. void JucerDocument::timerCallback()

  100. {

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

  102.     {

  103.         stopTimer();

  104.         beginTransaction();

  105. 

  106.         flushChangesToDocuments();

  107.     }

  108. }

  109. 

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

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

  112. 

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

  114. {

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

  116. }

  117. 

  118. void JucerDocument::refreshAllPropertyComps()

  119. {

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

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

  122. 

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

  124.     {

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

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

  127.     }

  128. }

  129. 

  130. //==============================================================================

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

  132. {

  133.     if (newName != className

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

  135.     {

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

  137.         changed();

  138.     }

  139. }

  140. 

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

  142. {

  143.     if (newName != componentName)

  144.     {

  145.         componentName = newName;

  146.         changed();

  147.     }

  148. }

  149. 

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

  151. {

  152.     if (classes != parentClasses)

  153.     {

  154.         StringArray parentClassLines;

  155.         parentClassLines.addTokens (classes, ",", String::empty);

  156.         parentClassLines.trim();

  157.         parentClassLines.removeEmptyStrings();

  158.         parentClassLines.removeDuplicates (false);

  159. 

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

  161.         {

  162.             String s (parentClassLines[i]);

  163.             String type;

  164. 

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

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

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

  168.             {

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

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

  171. 

  172.                 if (s.trim().isEmpty())

  173.                     type = s = String::empty;

  174.             }

  175. 

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

  177. 

  178.             parentClassLines.set (i, s);

  179.         }

  180. 

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

  182.         changed();

  183.     }

  184. }

  185. 

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

  187. {

  188.     if (constructorParams != newParams)

  189.     {

  190.         constructorParams = newParams;

  191.         changed();

  192.     }

  193. }

  194. 

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

  196. {

  197.     if (variableInitialisers != newInitlialisers)

  198.     {

  199.         variableInitialisers = newInitlialisers;

  200.         changed();

  201.     }

  202. }

  203. 

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

  205. {

  206.     if (fixedSize != isFixed)

  207.     {

  208.         fixedSize = isFixed;

  209.         changed();

  210.     }

  211. }

  212. 

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

  214. {

  215.     w = jmax (1, w);

  216.     h = jmax (1, h);

  217. 

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

  219.     {

  220.         initialWidth = w;

  221.         initialHeight = h;

  222.         changed();

  223.     }

  224. }

  225. 

  226. //==============================================================================

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

  228. {

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

  230. }

  231. 

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

  233. {

  234.     if (isSnapActive (true))

  235.     {

  236.         jassert (snapGridPixels > 0);

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

  238.     }

  239. 

  240.     return pos;

  241. }

  242. 

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

  244. {

  245.     if (numPixels != snapGridPixels

  246.          || active != snapActive

  247.          || shown != snapShown)

  248.     {

  249.         snapGridPixels = numPixels;

  250.         snapActive = active;

  251.         snapShown = shown;

  252.         changed();

  253.     }

  254. }

  255. 

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

  257. {

  258.     if (alpha != componentOverlayOpacity)

  259.     {

  260.         componentOverlayOpacity = alpha;

  261.         changed();

  262.     }

  263. }

  264. 

  265. //==============================================================================

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

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

  268. {

  269.     baseClasses.add (base);

  270.     returnValues.add (returnVal);

  271.     methods.add (method);

  272.     initialContents.add (initialContent);

  273. }

  274. 

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

  276.                                         StringArray& returnValues,

  277.                                         StringArray& methods,

  278.                                         StringArray& initialContents) const

  279. {

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

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

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

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

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

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

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

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

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

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

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

  291. 

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

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

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

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

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

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

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

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

  300. 

  301.     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);

  302.     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);

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

  304. 

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

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

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

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

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

  310. }

  311. 

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

  313. {

  314.     if (enable)

  315.         activeExtraMethods.addIfNotAlreadyThere (methodSignature);

  316.     else

  317.         activeExtraMethods.removeString (methodSignature);

  318. 

  319.     changed();

  320. }

  321. 

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

  323. {

  324.     return activeExtraMethods.contains (sig);

  325. }

  326. 

  327. void JucerDocument::addExtraClassProperties (PropertyPanel&)

  328. {

  329. }

  330. 

  331. //==============================================================================

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

  333. 

  334. XmlElement* JucerDocument::createXml() const

  335. {

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

  337. 

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

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

  340. 

  341.     if (templateFile.trim().isNotEmpty())

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

  343. 

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

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

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

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

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

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

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

  351.     doc->setAttribute ("overlayOpacity", (double) componentOverlayOpacity);

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

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

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

  355. 

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

  357.     {

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

  359.         doc->addChildElement (extraMethods);

  360. 

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

  362.         {

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

  364.             extraMethods ->addChildElement (e);

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

  366.         }

  367.     }

  368. 

  369.     return doc;

  370. }

  371. 

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

  373. {

  374.     if (xml.hasTagName (jucerCompXmlTag)

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

  376.     {

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

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

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

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

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

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

  383. 

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

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

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

  387. 

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

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

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

  391. 

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

  393. 

  394.         activeExtraMethods.clear();

  395. 

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

  397.         {

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

  399.             {

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

  401.             }

  402.         }

  403. 

  404.         activeExtraMethods.trim();

  405.         activeExtraMethods.removeEmptyStrings();

  406. 

  407.         changed();

  408.         getUndoManager().clearUndoHistory();

  409.         return true;

  410.     }

  411. 

  412.     return false;

  413. }

  414. 

  415. 

  416. //==============================================================================

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

  418. {

  419.     code.className = className;

  420.     code.componentName = componentName;

  421.     code.parentClasses = parentClasses;

  422.     code.constructorParams = constructorParams;

  423.     code.initialisers.addLines (variableInitialisers);

  424. 

  425.     if (! componentName.isEmpty())

  426.         code.parentClassInitialiser = "Component (" + quotedString (code.componentName) + ")";

  427. 

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

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

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

  431. 

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

  433. 

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

  435.         l->fillInGeneratedCode (code);

  436. 

  437.     fillInPaintCode (code);

  438. 

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

  440.     jassert (e != nullptr);

  441.     code.jucerMetadata = e->createDocument (String::empty, false, false);

  442. 

  443.     resources.fillInGeneratedCode (code);

  444. 

  445.     code.constructorCode

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

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

  448. 

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

  450.         code.constructorCode

  451.             << "\nsetSize (" << initialWidth << ", " << initialHeight << ");\n";

  452. 

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

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

  455. 

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

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

  458. 

  459.     // add optional methods

  460.     StringArray baseClasses, returnValues, methods, initialContents;

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

  462. 

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

  464.     {

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

  466.         {

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

  468. 

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

  470.             {

  471.                 String userCommentTag ("UserCode_");

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

  473. 

  474.                 s << "\n//["

  475.                   << userCommentTag

  476.                   << "] -- Add your code here...\n"

  477.                   << initialContents[i];

  478. 

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

  480.                     s << '\n';

  481. 

  482.                 s << "//[/"

  483.                   << userCommentTag

  484.                   << "]\n";

  485.             }

  486.         }

  487.     }

  488. }

  489. 

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

  491. {

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

  493.         getPaintRoutine (i)

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

  495. }

  496. 

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

  498. {

  499.     if (templateFile != newFile)

  500.     {

  501.         templateFile = newFile;

  502.         changed();

  503.     }

  504. }

  505. 

  506. //==============================================================================

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

  508. {

  509.     if (templateFile.isNotEmpty())

  510.     {

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

  512. 

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

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

  515. 

  516.         headerContent = templateH.loadFileAsString();

  517.         cppContent = templateCpp.loadFileAsString();

  518. 

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

  520.             return true;

  521.     }

  522. 

  523.     headerContent = BinaryData::jucer_ComponentTemplate_h;

  524.     cppContent    = BinaryData::jucer_ComponentTemplate_cpp;

  525.     return true;

  526. }

  527. 

  528. static String fixLineEndings (const String& s)

  529. {

  530.     StringArray lines;

  531.     lines.addLines (s);

  532. 

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

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

  535. 

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

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

  538. 

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

  540. 

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

  542. }

  543. 

  544. bool JucerDocument::flushChangesToDocuments()

  545. {

  546.     String headerTemplate, cppTemplate;

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

  548.         return false;

  549. 

  550.     GeneratedCode generated (this);

  551.     fillInGeneratedCode (generated);

  552. 

  553.     const File headerFile (getHeaderFile());

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

  555. 

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

  557. 

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

  559.     {

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

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

  562. 

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

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

  565. 

  566.         headerTemplate = fixLineEndings (headerTemplate);

  567.         cppTemplate    = fixLineEndings (cppTemplate);

  568. 

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

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

  571. 

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

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

  574.     }

  575. 

  576.     userDocChangeTimer = nullptr;

  577.     return true;

  578. }

  579. 

  580. bool JucerDocument::reloadFromDocument()

  581. {

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

  583. 

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

  585. 

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

  587.         return false;

  588. 

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

  590.         return true;

  591. 

  592.     currentXML = newXML;

  593.     stopTimer();

  594.     if (! loadFromXml (*currentXML))

  595.         return false;

  596. 

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

  598.     return true;

  599. }

  600. 

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

  602. {

  603.     StringArray lines;

  604.     lines.addLines (cpp);

  605. 

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

  607. 

  608.     if (startLine > 0)

  609.     {

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

  611. 

  612.         if (endLine > startLine)

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

  614.                                                              endLine - startLine - 1));

  615.     }

  616. 

  617.     return nullptr;

  618. }

  619. 

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

  621. {

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

  623.     {

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

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

  626.     }

  627. 

  628.     return false;

  629. }

  630. 

  631. static JucerDocument* createDocument (SourceCodeDocument* cpp)

  632. {

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

  634. 

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

  636. 

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

  638.         return nullptr;

  639. 

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

  641. 

  642.     ScopedPointer<JucerDocument> newDoc;

  643. 

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

  645.         newDoc = new ButtonDocument (cpp);

  646. 

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

  648.         newDoc = new ComponentDocument (cpp);

  649. 

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

  651.         return newDoc.release();

  652. 

  653.     return nullptr;

  654. }

  655. 

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

  657. {

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

  659. 

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

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

  662.             return createDocument (cpp);

  663. 

  664.     return nullptr;

  665. }

  666. 

  667. //==============================================================================

  668. class JucerComponentDocument  : public SourceCodeDocument

  669. {

  670. public:

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

  672.         : SourceCodeDocument (p, f)

  673.     {

  674.     }

  675. 

  676.     bool save()

  677.     {

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

  679.     }

  680. 

  681.     bool saveHeader()

  682.     {

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

  684. 

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

  686.             return header->save();

  687. 

  688.         return false;

  689.     }

  690. 

  691.     Component* createEditor()

  692.     {

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

  694. 

  695.         if (jucerDoc != nullptr)

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

  697. 

  698.         return SourceCodeDocument::createEditor();

  699.     }

  700. 

  701.     class Type  : public OpenDocumentManager::DocumentType

  702.     {

  703.     public:

  704.         Type() {}

  705. 

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

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

  708.     };

  709. };

  710. 

  711. OpenDocumentManager::DocumentType* createGUIDocumentType()

  712. {

  713.     return new JucerComponentDocument::Type();

  714. }

  715. 

  716. //==============================================================================

  717. class JucerFileWizard  : public NewFileWizard::Type

  718. {

  719. public:

  720.     JucerFileWizard() {}

  721. 

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

  723. 

  724.     void createNewFile (Project::Item parent)

  725.     {

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

  727. 

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

  729.         {

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

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

  732. 

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

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

  735. 

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

  737. 

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

  739.             {

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

  741.                 {

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

  743. 

  744.                     if (jucerDoc != nullptr)

  745.                     {

  746.                         jucerDoc->flushChangesToDocuments();

  747.                         jucerDoc = nullptr;

  748. 

  749.                         cpp->save();

  750.                         header->save();

  751.                         odm.closeDocument (cpp, true);

  752.                         odm.closeDocument (header, true);

  753. 

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

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

  756.                     }

  757.                 }

  758.             }

  759.         }

  760.     }

  761. };

  762. 

  763. NewFileWizard::Type* createGUIComponentWizard()

  764. {

  765.     return new JucerFileWizard();

  766. }