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.
3010 Commits
11 Branches
314MB
Tree: bb008cb1ba
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bb008cb1ba'
${ noResults }
JUCE/extras/Introjucer/Source/ComponentEditor/jucer_JucerDocument.cpp

724 lines
26KB
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& methodSigniture, const bool enable)

  314. {

  315.     if (enable)

  316.         activeExtraMethods.addIfNotAlreadyThere (methodSigniture);

  317.     else

  318.         activeExtraMethods.removeString (methodSigniture);

  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. bool JucerDocument::flushChangesToDocuments()

  530. {

  531.     String headerTemplate, cppTemplate;

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

  533.         return false;

  534. 

  535.     GeneratedCode generated (this);

  536.     fillInGeneratedCode (generated);

  537. 

  538.     const File headerFile (getHeaderFile());

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

  540. 

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

  542. 

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

  544.     {

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

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

  547. 

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

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

  550. 

  551.         header->getCodeDocument().applyChanges (headerTemplate);

  552.         cpp->getCodeDocument().applyChanges (cppTemplate);

  553.     }

  554. 

  555.     return true;

  556. }

  557. 

  558. bool JucerDocument::reloadFromDocument()

  559. {

  560.     ScopedPointer<XmlElement> newXML (pullMetaDataFromCppFile (cpp->getCodeDocument().getAllContent()));

  561. 

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

  563.         return false;

  564. 

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

  566.         return true;

  567. 

  568.     currentXML = newXML;

  569.     stopTimer();

  570.     return loadFromXml (*currentXML);

  571. }

  572. 

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

  574. {

  575.     StringArray lines;

  576.     lines.addLines (cpp);

  577. 

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

  579. 

  580.     if (startLine > 0)

  581.     {

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

  583. 

  584.         if (endLine > startLine)

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

  586.                                                              endLine - startLine - 1));

  587.     }

  588. 

  589.     return nullptr;

  590. }

  591. 

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

  593. {

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

  595.     {

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

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

  598.     }

  599. 

  600.     return false;

  601. }

  602. 

  603. static JucerDocument* createDocument (SourceCodeDocument* cpp)

  604. {

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

  606. 

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

  608. 

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

  610.         return nullptr;

  611. 

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

  613. 

  614.     ScopedPointer<JucerDocument> newDoc;

  615. 

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

  617.         newDoc = new ButtonDocument (cpp);

  618. 

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

  620.         newDoc = new ComponentDocument (cpp);

  621. 

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

  623.         return newDoc.release();

  624. 

  625.     return nullptr;

  626. }

  627. 

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

  629. {

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

  631. 

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

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

  634.             return createDocument (cpp);

  635. 

  636.     return nullptr;

  637. }

  638. 

  639. //==============================================================================

  640. class JucerComponentDocument  : public SourceCodeDocument

  641. {

  642. public:

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

  644.         : SourceCodeDocument (p, f)

  645.     {

  646.     }

  647. 

  648.     Component* createEditor()

  649.     {

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

  651. 

  652.         if (jucerDoc != nullptr)

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

  654. 

  655.         return SourceCodeDocument::createEditor();

  656.     }

  657. 

  658.     class Type  : public OpenDocumentManager::DocumentType

  659.     {

  660.     public:

  661.         Type() {}

  662. 

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

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

  665.     };

  666. };

  667. 

  668. OpenDocumentManager::DocumentType* createGUIDocumentType()

  669. {

  670.     return new JucerComponentDocument::Type();

  671. }

  672. 

  673. //==============================================================================

  674. class JucerFileWizard  : public NewFileWizard::Type

  675. {

  676. public:

  677.     JucerFileWizard() {}

  678. 

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

  680. 

  681.     void createNewFile (Project::Item parent)

  682.     {

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

  684. 

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

  686.         {

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

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

  689. 

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

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

  692. 

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

  694. 

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

  696.             {

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

  698.                 {

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

  700. 

  701.                     if (jucerDoc != nullptr)

  702.                     {

  703.                         jucerDoc->flushChangesToDocuments();

  704.                         jucerDoc = nullptr;

  705. 

  706.                         cpp->save();

  707.                         header->save();

  708.                         odm.closeDocument (cpp, true);

  709.                         odm.closeDocument (header, true);

  710. 

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

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

  713.                     }

  714.                 }

  715.             }

  716.         }

  717.     }

  718. };

  719. 

  720. NewFileWizard::Type* createGUIComponentWizard()

  721. {

  722.     return new JucerFileWizard();

  723. }