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

768 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

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

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

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

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

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

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. #include "../jucer_Headers.h"

  27. #include "../Application/jucer_Application.h"

  28. #include "../Project/jucer_NewFileWizard.h"

  29. #include "jucer_JucerDocument.h"

  30. #include "jucer_ObjectTypes.h"

  31. #include "ui/jucer_JucerDocumentEditor.h"

  32. #include "ui/jucer_TestComponent.h"

  33. #include "jucer_UtilityFunctions.h"

  34. #include "documents/jucer_ComponentDocument.h"

  35. #include "documents/jucer_ButtonDocument.h"

  36. 

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

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

  39. 

  40. //==============================================================================

  41. JucerDocument::JucerDocument (SourceCodeDocument* c)

  42.     : cpp (c),

  43.       className (defaultClassName),

  44.       parentClasses (defaultParentClasses),

  45.       fixedSize (false),

  46.       initialWidth (600),

  47.       initialHeight (400),

  48.       snapGridPixels (8),

  49.       snapActive (true),

  50.       snapShown (true),

  51.       componentOverlayOpacity (0.33f)

  52. {

  53.     jassert (cpp != nullptr);

  54.     resources.setDocument (this);

  55. 

  56.     commandManager->commandStatusChanged();

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

  58. }

  59. 

  60. JucerDocument::~JucerDocument()

  61. {

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

  63.     commandManager->commandStatusChanged();

  64. }

  65. 

  66. //==============================================================================

  67. void JucerDocument::changed()

  68. {

  69.     sendChangeMessage();

  70.     commandManager->commandStatusChanged();

  71.     startTimer (800);

  72. }

  73. 

  74. struct UserDocChangeTimer  : public Timer

  75. {

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

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

  78. 

  79.     JucerDocument& doc;

  80. };

  81. 

  82. void JucerDocument::userEditedCpp()

  83. {

  84.     if (userDocChangeTimer == nullptr)

  85.         userDocChangeTimer = new UserDocChangeTimer (*this);

  86. 

  87.     userDocChangeTimer->startTimer (500);

  88. }

  89. 

  90. void JucerDocument::beginTransaction()

  91. {

  92.     getUndoManager().beginNewTransaction();

  93. }

  94. 

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

  96. {

  97.     getUndoManager().beginNewTransaction (name);

  98. }

  99. 

  100. void JucerDocument::timerCallback()

  101. {

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

  103.     {

  104.         stopTimer();

  105.         beginTransaction();

  106. 

  107.         flushChangesToDocuments();

  108.     }

  109. }

  110. 

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

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

  113. 

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

  115. {

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

  117. }

  118. 

  119. void JucerDocument::refreshAllPropertyComps()

  120. {

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

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

  123. 

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

  125.     {

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

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

  128.     }

  129. }

  130. 

  131. //==============================================================================

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

  133. {

  134.     if (newName != className

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

  136.     {

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

  138.         changed();

  139.     }

  140. }

  141. 

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

  143. {

  144.     if (newName != componentName)

  145.     {

  146.         componentName = newName;

  147.         changed();

  148.     }

  149. }

  150. 

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

  152. {

  153.     if (classes != parentClasses)

  154.     {

  155.         StringArray parentClassLines;

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

  157.         parentClassLines.trim();

  158.         parentClassLines.removeEmptyStrings();

  159.         parentClassLines.removeDuplicates (false);

  160. 

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

  162.         {

  163.             String s (parentClassLines[i]);

  164.             String type;

  165. 

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

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

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

  169.             {

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

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

  172. 

  173.                 if (s.trim().isEmpty())

  174.                     type = s = String::empty;

  175.             }

  176. 

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

  178. 

  179.             parentClassLines.set (i, s);

  180.         }

  181. 

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

  183.         changed();

  184.     }

  185. }

  186. 

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

  188. {

  189.     if (constructorParams != newParams)

  190.     {

  191.         constructorParams = newParams;

  192.         changed();

  193.     }

  194. }

  195. 

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

  197. {

  198.     if (variableInitialisers != newInitlialisers)

  199.     {

  200.         variableInitialisers = newInitlialisers;

  201.         changed();

  202.     }

  203. }

  204. 

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

  206. {

  207.     if (fixedSize != isFixed)

  208.     {

  209.         fixedSize = isFixed;

  210.         changed();

  211.     }

  212. }

  213. 

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

  215. {

  216.     w = jmax (1, w);

  217.     h = jmax (1, h);

  218. 

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

  220.     {

  221.         initialWidth = w;

  222.         initialHeight = h;

  223.         changed();

  224.     }

  225. }

  226. 

  227. //==============================================================================

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

  229. {

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

  231. }

  232. 

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

  234. {

  235.     if (isSnapActive (true))

  236.     {

  237.         jassert (snapGridPixels > 0);

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

  239.     }

  240. 

  241.     return pos;

  242. }

  243. 

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

  245. {

  246.     if (numPixels != snapGridPixels

  247.          || active != snapActive

  248.          || shown != snapShown)

  249.     {

  250.         snapGridPixels = numPixels;

  251.         snapActive = active;

  252.         snapShown = shown;

  253.         changed();

  254.     }

  255. }

  256. 

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

  258. {

  259.     if (alpha != componentOverlayOpacity)

  260.     {

  261.         componentOverlayOpacity = alpha;

  262.         changed();

  263.     }

  264. }

  265. 

  266. //==============================================================================

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

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

  269. {

  270.     baseClasses.add (base);

  271.     returnValues.add (returnVal);

  272.     methods.add (method);

  273.     initialContents.add (initialContent);

  274. }

  275. 

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

  277.                                         StringArray& returnValues,

  278.                                         StringArray& methods,

  279.                                         StringArray& initialContents) const

  280. {

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

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

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

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

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

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

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

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

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

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

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

  292. 

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

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

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

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

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

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

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

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

  301. 

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

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

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

  305. 

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

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

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

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

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

  311. }

  312. 

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

  314. {

  315.     if (enable)

  316.         activeExtraMethods.addIfNotAlreadyThere (methodSignature);

  317.     else

  318.         activeExtraMethods.removeString (methodSignature);

  319. 

  320.     changed();

  321. }

  322. 

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

  324. {

  325.     return activeExtraMethods.contains (sig);

  326. }

  327. 

  328. void JucerDocument::addExtraClassProperties (PropertyPanel&)

  329. {

  330. }

  331. 

  332. //==============================================================================

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

  334. 

  335. XmlElement* JucerDocument::createXml() const

  336. {

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

  338. 

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

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

  341. 

  342.     if (templateFile.trim().isNotEmpty())

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

  344. 

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

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

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

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

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

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

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

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

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

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

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

  356. 

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

  358.     {

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

  360.         doc->addChildElement (extraMethods);

  361. 

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

  363.         {

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

  365.             extraMethods ->addChildElement (e);

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

  367.         }

  368.     }

  369. 

  370.     return doc;

  371. }

  372. 

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

  374. {

  375.     if (xml.hasTagName (jucerCompXmlTag)

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

  377.     {

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

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

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

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

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

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

  384. 

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

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

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

  388. 

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

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

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

  392. 

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

  394. 

  395.         activeExtraMethods.clear();

  396. 

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

  398.         {

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

  400.             {

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

  402.             }

  403.         }

  404. 

  405.         activeExtraMethods.trim();

  406.         activeExtraMethods.removeEmptyStrings();

  407. 

  408.         changed();

  409.         getUndoManager().clearUndoHistory();

  410.         return true;

  411.     }

  412. 

  413.     return false;

  414. }

  415. 

  416. 

  417. //==============================================================================

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

  419. {

  420.     code.className = className;

  421.     code.componentName = componentName;

  422.     code.parentClasses = parentClasses;

  423.     code.constructorParams = constructorParams;

  424.     code.initialisers.addLines (variableInitialisers);

  425. 

  426.     if (! componentName.isEmpty())

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

  428. 

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

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

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

  432. 

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

  434. 

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

  436.         l->fillInGeneratedCode (code);

  437. 

  438.     fillInPaintCode (code);

  439. 

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

  441.     jassert (e != nullptr);

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

  443. 

  444.     resources.fillInGeneratedCode (code);

  445. 

  446.     code.constructorCode

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

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

  449. 

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

  451.         code.constructorCode

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

  453. 

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

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

  456. 

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

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

  459. 

  460.     // add optional methods

  461.     StringArray baseClasses, returnValues, methods, initialContents;

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

  463. 

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

  465.     {

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

  467.         {

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

  469. 

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

  471.             {

  472.                 String userCommentTag ("UserCode_");

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

  474. 

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

  476.                   << userCommentTag

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

  478.                   << initialContents[i];

  479. 

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

  481.                     s << '\n';

  482. 

  483.                 s << "//[/"

  484.                   << userCommentTag

  485.                   << "]\n";

  486.             }

  487.         }

  488.     }

  489. }

  490. 

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

  492. {

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

  494.         getPaintRoutine (i)

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

  496. }

  497. 

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

  499. {

  500.     if (templateFile != newFile)

  501.     {

  502.         templateFile = newFile;

  503.         changed();

  504.     }

  505. }

  506. 

  507. //==============================================================================

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

  509. {

  510.     if (templateFile.isNotEmpty())

  511.     {

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

  513. 

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

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

  516. 

  517.         headerContent = templateH.loadFileAsString();

  518.         cppContent = templateCpp.loadFileAsString();

  519. 

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

  521.             return true;

  522.     }

  523. 

  524.     headerContent = BinaryData::jucer_ComponentTemplate_h;

  525.     cppContent    = BinaryData::jucer_ComponentTemplate_cpp;

  526.     return true;

  527. }

  528. 

  529. static String fixLineEndings (const String& s)

  530. {

  531.     StringArray lines;

  532.     lines.addLines (s);

  533. 

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

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

  536. 

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

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

  539. 

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

  541. 

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

  543. }

  544. 

  545. bool JucerDocument::flushChangesToDocuments()

  546. {

  547.     String headerTemplate, cppTemplate;

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

  549.         return false;

  550. 

  551.     GeneratedCode generated (this);

  552.     fillInGeneratedCode (generated);

  553. 

  554.     const File headerFile (getHeaderFile());

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

  556. 

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

  558. 

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

  560.     {

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

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

  563. 

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

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

  566. 

  567.         headerTemplate = fixLineEndings (headerTemplate);

  568.         cppTemplate    = fixLineEndings (cppTemplate);

  569. 

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

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

  572. 

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

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

  575.     }

  576. 

  577.     userDocChangeTimer = nullptr;

  578.     return true;

  579. }

  580. 

  581. bool JucerDocument::reloadFromDocument()

  582. {

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

  584. 

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

  586. 

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

  588.         return false;

  589. 

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

  591.         return true;

  592. 

  593.     currentXML = newXML;

  594.     stopTimer();

  595.     if (! loadFromXml (*currentXML))

  596.         return false;

  597. 

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

  599.     return true;

  600. }

  601. 

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

  603. {

  604.     StringArray lines;

  605.     lines.addLines (cpp);

  606. 

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

  608. 

  609.     if (startLine > 0)

  610.     {

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

  612. 

  613.         if (endLine > startLine)

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

  615.                                                              endLine - startLine - 1));

  616.     }

  617. 

  618.     return nullptr;

  619. }

  620. 

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

  622. {

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

  624.     {

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

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

  627.     }

  628. 

  629.     return false;

  630. }

  631. 

  632. static JucerDocument* createDocument (SourceCodeDocument* cpp)

  633. {

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

  635. 

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

  637. 

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

  639.         return nullptr;

  640. 

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

  642. 

  643.     ScopedPointer<JucerDocument> newDoc;

  644. 

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

  646.         newDoc = new ButtonDocument (cpp);

  647. 

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

  649.         newDoc = new ComponentDocument (cpp);

  650. 

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

  652.         return newDoc.release();

  653. 

  654.     return nullptr;

  655. }

  656. 

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

  658. {

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

  660. 

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

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

  663.             return createDocument (cpp);

  664. 

  665.     return nullptr;

  666. }

  667. 

  668. //==============================================================================

  669. class JucerComponentDocument  : public SourceCodeDocument

  670. {

  671. public:

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

  673.         : SourceCodeDocument (p, f)

  674.     {

  675.     }

  676. 

  677.     bool save()

  678.     {

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

  680.     }

  681. 

  682.     bool saveHeader()

  683.     {

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

  685. 

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

  687.             return header->save();

  688. 

  689.         return false;

  690.     }

  691. 

  692.     Component* createEditor()

  693.     {

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

  695. 

  696.         if (jucerDoc != nullptr)

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

  698. 

  699.         return SourceCodeDocument::createEditor();

  700.     }

  701. 

  702.     class Type  : public OpenDocumentManager::DocumentType

  703.     {

  704.     public:

  705.         Type() {}

  706. 

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

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

  709.     };

  710. };

  711. 

  712. OpenDocumentManager::DocumentType* createGUIDocumentType()

  713. {

  714.     return new JucerComponentDocument::Type();

  715. }

  716. 

  717. //==============================================================================

  718. class JucerFileWizard  : public NewFileWizard::Type

  719. {

  720. public:

  721.     JucerFileWizard() {}

  722. 

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

  724. 

  725.     void createNewFile (Project::Item parent)

  726.     {

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

  728. 

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

  730.         {

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

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

  733. 

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

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

  736. 

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

  738. 

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

  740.             {

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

  742.                 {

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

  744. 

  745.                     if (jucerDoc != nullptr)

  746.                     {

  747.                         jucerDoc->flushChangesToDocuments();

  748.                         jucerDoc = nullptr;

  749. 

  750.                         cpp->save();

  751.                         header->save();

  752.                         odm.closeDocument (cpp, true);

  753.                         odm.closeDocument (header, true);

  754. 

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

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

  757.                     }

  758.                 }

  759.             }

  760.         }

  761.     }

  762. };

  763. 

  764. NewFileWizard::Type* createGUIComponentWizard()

  765. {

  766.     return new JucerFileWizard();

  767. }