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

769 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.     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, ",", String::empty);

  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. 

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

  438.         l->fillInGeneratedCode (code);

  439. 

  440.     fillInPaintCode (code);

  441. 

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

  443.     jassert (e != nullptr);

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

  445. 

  446.     resources.fillInGeneratedCode (code);

  447. 

  448.     code.constructorCode

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

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

  451. 

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

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

  454. 

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

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

  457. 

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

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

  460. 

  461.     // add optional methods

  462.     StringArray baseClasses, returnValues, methods, initialContents;

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

  464. 

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

  466.     {

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

  468.         {

  469.             String baseClassToAdd (baseClasses[i]);

  470. 

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

  472.                 baseClassToAdd.clear();

  473. 

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

  475. 

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

  477.             {

  478.                 String userCommentTag ("UserCode_");

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

  480. 

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

  482.                   << initialContents[i];

  483. 

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

  485.                     s << '\n';

  486. 

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

  488.             }

  489.         }

  490.     }

  491. }

  492. 

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

  494. {

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

  496.         getPaintRoutine (i)

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

  498. }

  499. 

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

  501. {

  502.     if (templateFile != newFile)

  503.     {

  504.         templateFile = newFile;

  505.         changed();

  506.     }

  507. }

  508. 

  509. //==============================================================================

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

  511. {

  512.     if (templateFile.isNotEmpty())

  513.     {

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

  515. 

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

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

  518. 

  519.         headerContent = templateH.loadFileAsString();

  520.         cppContent = templateCpp.loadFileAsString();

  521. 

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

  523.             return true;

  524.     }

  525. 

  526.     headerContent = BinaryData::jucer_ComponentTemplate_h;

  527.     cppContent    = BinaryData::jucer_ComponentTemplate_cpp;

  528.     return true;

  529. }

  530. 

  531. static String fixLineEndings (const String& s)

  532. {

  533.     StringArray lines;

  534.     lines.addLines (s);

  535. 

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

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

  538. 

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

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

  541. 

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

  543. 

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

  545. }

  546. 

  547. bool JucerDocument::flushChangesToDocuments()

  548. {

  549.     String headerTemplate, cppTemplate;

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

  551.         return false;

  552. 

  553.     GeneratedCode generated (this);

  554.     fillInGeneratedCode (generated);

  555. 

  556.     const File headerFile (getHeaderFile());

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

  558. 

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

  560. 

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

  562.     {

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

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

  565. 

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

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

  568. 

  569.         headerTemplate = fixLineEndings (headerTemplate);

  570.         cppTemplate    = fixLineEndings (cppTemplate);

  571. 

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

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

  574. 

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

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

  577.     }

  578. 

  579.     userDocChangeTimer = nullptr;

  580.     return true;

  581. }

  582. 

  583. bool JucerDocument::reloadFromDocument()

  584. {

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

  586. 

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

  588. 

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

  590.         return false;

  591. 

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

  593.         return true;

  594. 

  595.     currentXML = newXML;

  596.     stopTimer();

  597. 

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

  599. 

  600.     return loadFromXml (*currentXML);

  601. }

  602. 

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

  604. {

  605.     StringArray lines;

  606.     lines.addLines (cpp);

  607. 

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

  609. 

  610.     if (startLine > 0)

  611.     {

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

  613. 

  614.         if (endLine > startLine)

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

  616.                                                              endLine - startLine - 1));

  617.     }

  618. 

  619.     return nullptr;

  620. }

  621. 

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

  623. {

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

  625.     {

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

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

  628.     }

  629. 

  630.     return false;

  631. }

  632. 

  633. static JucerDocument* createDocument (SourceCodeDocument* cpp)

  634. {

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

  636. 

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

  638. 

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

  640.         return nullptr;

  641. 

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

  643. 

  644.     ScopedPointer<JucerDocument> newDoc;

  645. 

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

  647.         newDoc = new ButtonDocument (cpp);

  648. 

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

  650.         newDoc = new ComponentDocument (cpp);

  651. 

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

  653.         return newDoc.release();

  654. 

  655.     return nullptr;

  656. }

  657. 

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

  659. {

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

  661. 

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

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

  664.             return createDocument (cpp);

  665. 

  666.     return nullptr;

  667. }

  668. 

  669. //==============================================================================

  670. class JucerComponentDocument  : public SourceCodeDocument

  671. {

  672. public:

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

  674.         : SourceCodeDocument (p, f)

  675.     {

  676.     }

  677. 

  678.     bool save() override

  679.     {

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

  681.     }

  682. 

  683.     bool saveHeader()

  684.     {

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

  686. 

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

  688.             return header->save();

  689. 

  690.         return false;

  691.     }

  692. 

  693.     Component* createEditor() override

  694.     {

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

  696. 

  697.         if (jucerDoc != nullptr)

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

  699. 

  700.         return SourceCodeDocument::createEditor();

  701.     }

  702. 

  703.     class Type  : public OpenDocumentManager::DocumentType

  704.     {

  705.     public:

  706.         Type() {}

  707. 

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

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

  710.     };

  711. };

  712. 

  713. OpenDocumentManager::DocumentType* createGUIDocumentType()

  714. {

  715.     return new JucerComponentDocument::Type();

  716. }

  717. 

  718. //==============================================================================

  719. class JucerFileWizard  : public NewFileWizard::Type

  720. {

  721. public:

  722.     JucerFileWizard() {}

  723. 

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

  725. 

  726.     void createNewFile (Project::Item parent)

  727.     {

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

  729. 

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

  731.         {

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

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

  734. 

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

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

  737. 

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

  739. 

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

  741.             {

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

  743.                 {

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

  745. 

  746.                     if (jucerDoc != nullptr)

  747.                     {

  748.                         jucerDoc->flushChangesToDocuments();

  749.                         jucerDoc = nullptr;

  750. 

  751.                         cpp->save();

  752.                         header->save();

  753.                         odm.closeDocument (cpp, true);

  754.                         odm.closeDocument (header, true);

  755. 

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

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

  758.                     }

  759.                 }

  760.             }

  761.         }

  762.     }

  763. };

  764. 

  765. NewFileWizard::Type* createGUIComponentWizard()

  766. {

  767.     return new JucerFileWizard();

  768. }