juce/source/extras/Introjucer/Source/Application/jucer_OpenDocumentManager.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library - "Jules' Utility Class Extensions"
   5    Copyright 2004-10 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_OpenDocumentManager.h"
  27 #include "jucer_FilePreviewComponent.h"
  28 #include "../Code Editor/jucer_SourceCodeEditor.h"
  29
  30
  31 //==============================================================================
  32 class SourceCodeDocument  : public OpenDocumentManager::Document
  33 {
  34 public:
  35     //==============================================================================
  36     SourceCodeDocument (const File& file_)
  37         : modDetector (file_)
  38     {
  39         codeDoc = new CodeDocument();
  40         reloadFromFile();
  41     }
  42
  43     ~SourceCodeDocument()
  44     {
  45     }
  46
  47     //==============================================================================
  48     class Type  : public OpenDocumentManager::DocumentType
  49     {
  50     public:
  51         Type() {}
  52         ~Type() {}
  53
  54         bool canOpenFile (const File& file)                 { return SourceCodeEditor::isTextFile (file); }
  55         Document* openFile (Project*, const File& file)     { return new SourceCodeDocument (file); }
  56     };
  57
  58     //==============================================================================
  59     bool loadedOk() const                               { return true; }
  60     bool isForFile (const File& file) const             { return modDetector.getFile() == file; }
  61     bool isForNode (const ValueTree& node) const        { return false; }
  62     bool refersToProject (Project& project) const       { return false; }
  63     const String getName() const                        { return modDetector.getFile().getFileName(); }
  64     const String getType() const                        { return modDetector.getFile().getFileExtension() + " file"; }
  65     bool needsSaving() const                            { return codeDoc != nullptr && codeDoc->hasChangedSinceSavePoint(); }
  66     bool hasFileBeenModifiedExternally()                { return modDetector.hasBeenModified(); }
  67     void fileHasBeenRenamed (const File& newFile)       { modDetector.fileHasBeenRenamed (newFile); }
  68
  69     void reloadFromFile()
  70     {
  71         modDetector.updateHash();
  72
  73         ScopedPointer <InputStream> in (modDetector.getFile().createInputStream());
  74
  75         if (in != nullptr)
  76             codeDoc->loadFromStream (*in);
  77     }
  78
  79     bool save()
  80     {
  81         TemporaryFile temp (modDetector.getFile());
  82         ScopedPointer <FileOutputStream> out (temp.getFile().createOutputStream());
  83
  84         if (out == nullptr || ! codeDoc->writeToStream (*out))
  85             return false;
  86
  87         out = nullptr;
  88         if (! temp.overwriteTargetFileWithTemporary())
  89             return false;
  90
  91         modDetector.updateHash();
  92         return true;
  93     }
  94
  95     Component* createEditor()
  96     {
  97         CodeTokeniser* tokeniser = nullptr;
  98
  99         if (SourceCodeEditor::isCppFile (modDetector.getFile()))
 100             tokeniser = &cppTokeniser;
 101
 102         return new SourceCodeEditor (this, *codeDoc, tokeniser);
 103     }
 104
 105     Component* createViewer()       { return createEditor(); }
 106
 107 private:
 108     FileModificationDetector modDetector;
 109     ScopedPointer <CodeDocument> codeDoc;
 110     CPlusPlusCodeTokeniser cppTokeniser;
 111 };
 112
 113 //==============================================================================
 114 class UnknownDocument  : public OpenDocumentManager::Document
 115 {
 116 public:
 117     UnknownDocument (Project* project_, const File& file_)
 118        : project (project_), file (file_)
 119     {
 120         reloadFromFile();
 121     }
 122
 123     ~UnknownDocument() {}
 124
 125     //==============================================================================
 126     class Type  : public OpenDocumentManager::DocumentType
 127     {
 128     public:
 129         Type() {}
 130         ~Type() {}
 131
 132         bool canOpenFile (const File& file)                         { return true; }
 133         Document* openFile (Project* project, const File& file)     { return new UnknownDocument (project, file); }
 134     };
 135
 136     //==============================================================================
 137     bool loadedOk() const                           { return true; }
 138     bool isForFile (const File& file_) const        { return file == file_; }
 139     bool isForNode (const ValueTree& node_) const   { return false; }
 140     bool refersToProject (Project& p) const         { return project == &p; }
 141     bool needsSaving() const                        { return false; }
 142     bool save()                                     { return true; }
 143     bool hasFileBeenModifiedExternally()            { return fileModificationTime != file.getLastModificationTime(); }
 144     void reloadFromFile()                           { fileModificationTime = file.getLastModificationTime(); }
 145     const String getName() const                    { return file.getFileName(); }
 146     Component* createEditor()                       { return new ItemPreviewComponent (file); }
 147     Component* createViewer()                       { return createEditor(); }
 148     void fileHasBeenRenamed (const File& newFile)   { file = newFile; }
 149
 150     const String getType() const
 151     {
 152         if (file.getFileExtension().isNotEmpty())
 153             return file.getFileExtension() + " file";
 154
 155         jassertfalse
 156         return "Unknown";
 157     }
 158
 159 private:
 160     Project* const project;
 161     File file;
 162     Time fileModificationTime;
 163
 164     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (UnknownDocument);
 165 };
 166
 167
 168 //==============================================================================
 169 OpenDocumentManager::OpenDocumentManager()
 170 {
 171     registerType (new UnknownDocument::Type());
 172     registerType (new SourceCodeDocument::Type());
 173 }
 174
 175 OpenDocumentManager::~OpenDocumentManager()
 176 {
 177     clearSingletonInstance();
 178 }
 179
 180 juce_ImplementSingleton_SingleThreaded (OpenDocumentManager);
 181
 182 //==============================================================================
 183 void OpenDocumentManager::registerType (DocumentType* type)
 184 {
 185     types.add (type);
 186 }
 187
 188 //==============================================================================
 189 void OpenDocumentManager::addListener (DocumentCloseListener* listener)
 190 {
 191     listeners.addIfNotAlreadyThere (listener);
 192 }
 193
 194 void OpenDocumentManager::removeListener (DocumentCloseListener* listener)
 195 {
 196     listeners.removeValue (listener);
 197 }
 198
 199 //==============================================================================
 200 bool OpenDocumentManager::canOpenFile (const File& file)
 201 {
 202     for (int i = types.size(); --i >= 0;)
 203         if (types.getUnchecked(i)->canOpenFile (file))
 204             return true;
 205
 206     return false;
 207 }
 208
 209 OpenDocumentManager::Document* OpenDocumentManager::getDocumentForFile (Project* project, const File& file)
 210 {
 211     for (int i = documents.size(); --i >= 0;)
 212         if (documents.getUnchecked(i)->isForFile (file))
 213             return documents.getUnchecked(i);
 214
 215     Document* d = nullptr;
 216
 217     for (int i = types.size(); --i >= 0 && d == nullptr;)
 218     {
 219         if (types.getUnchecked(i)->canOpenFile (file))
 220         {
 221             d = types.getUnchecked(i)->openFile (project, file);
 222             jassert (d != nullptr);
 223         }
 224     }
 225
 226     jassert (d != nullptr);
 227
 228     if (d != nullptr)
 229         documents.add (d);
 230
 231     commandManager->commandStatusChanged();
 232     return d;
 233 }
 234
 235 int OpenDocumentManager::getNumOpenDocuments() const
 236 {
 237     return documents.size();
 238 }
 239
 240 OpenDocumentManager::Document* OpenDocumentManager::getOpenDocument (int index) const
 241 {
 242     return documents.getUnchecked (index);
 243 }
 244
 245 void OpenDocumentManager::moveDocumentToTopOfStack (Document* doc)
 246 {
 247     for (int i = documents.size(); --i >= 0;)
 248     {
 249         if (doc == documents.getUnchecked(i))
 250         {
 251             documents.move (i, 0);
 252             commandManager->commandStatusChanged();
 253             break;
 254         }
 255     }
 256 }
 257
 258 FileBasedDocument::SaveResult OpenDocumentManager::saveIfNeededAndUserAgrees (OpenDocumentManager::Document* doc)
 259 {
 260     if (! doc->needsSaving())
 261         return FileBasedDocument::savedOk;
 262
 263     const int r = AlertWindow::showYesNoCancelBox (AlertWindow::QuestionIcon,
 264                                                    TRANS("Closing document..."),
 265                                                    TRANS("Do you want to save the changes to \"")
 266                                                        + doc->getName() + "\"?",
 267                                                    TRANS("save"),
 268                                                    TRANS("discard changes"),
 269                                                    TRANS("cancel"));
 270
 271     if (r == 1)
 272     {
 273         // save changes
 274         return doc->save() ? FileBasedDocument::savedOk
 275                            : FileBasedDocument::failedToWriteToFile;
 276     }
 277     else if (r == 2)
 278     {
 279         // discard changes
 280         return FileBasedDocument::savedOk;
 281     }
 282
 283     return FileBasedDocument::userCancelledSave;
 284 }
 285
 286
 287 bool OpenDocumentManager::closeDocument (int index, bool saveIfNeeded)
 288 {
 289     Document* doc = documents [index];
 290
 291     if (doc != nullptr)
 292     {
 293         if (saveIfNeeded)
 294         {
 295             if (saveIfNeededAndUserAgrees (doc) != FileBasedDocument::savedOk)
 296                 return false;
 297         }
 298
 299         for (int i = listeners.size(); --i >= 0;)
 300             listeners.getUnchecked(i)->documentAboutToClose (doc);
 301
 302         documents.remove (index);
 303         commandManager->commandStatusChanged();
 304     }
 305
 306     return true;
 307 }
 308
 309 bool OpenDocumentManager::closeDocument (Document* document, bool saveIfNeeded)
 310 {
 311     return closeDocument (documents.indexOf (document), saveIfNeeded);
 312 }
 313
 314 void OpenDocumentManager::closeFile (const File& f, bool saveIfNeeded)
 315 {
 316     for (int i = documents.size(); --i >= 0;)
 317     {
 318         Document* d = documents.getUnchecked (i);
 319
 320         if (d->isForFile (f))
 321             closeDocument (i, saveIfNeeded);
 322     }
 323 }
 324
 325 bool OpenDocumentManager::closeAllDocumentsUsingProject (Project& project, bool saveIfNeeded)
 326 {
 327     for (int i = documents.size(); --i >= 0;)
 328     {
 329         Document* d = documents.getUnchecked (i);
 330
 331         if (d->refersToProject (project))
 332         {
 333             if (! closeDocument (i, saveIfNeeded))
 334                 return false;
 335         }
 336     }
 337
 338     return true;
 339 }
 340
 341 bool OpenDocumentManager::anyFilesNeedSaving() const
 342 {
 343     for (int i = documents.size(); --i >= 0;)
 344     {
 345         Document* d = documents.getUnchecked (i);
 346
 347         if (d->needsSaving())
 348             return true;
 349     }
 350
 351     return false;
 352 }
 353
 354 bool OpenDocumentManager::saveAll()
 355 {
 356     for (int i = documents.size(); --i >= 0;)
 357     {
 358         Document* d = documents.getUnchecked (i);
 359
 360         if (! d->save())
 361             return false;
 362     }
 363
 364     return true;
 365 }
 366
 367 void OpenDocumentManager::reloadModifiedFiles()
 368 {
 369     for (int i = documents.size(); --i >= 0;)
 370     {
 371         Document* d = documents.getUnchecked (i);
 372
 373         if (d->hasFileBeenModifiedExternally())
 374             d->reloadFromFile();
 375     }
 376 }
 377
 378 void OpenDocumentManager::fileHasBeenRenamed (const File& oldFile, const File& newFile)
 379 {
 380     for (int i = documents.size(); --i >= 0;)
 381     {
 382         Document* d = documents.getUnchecked (i);
 383
 384         if (d->isForFile (oldFile))
 385             d->fileHasBeenRenamed (newFile);
 386     }
 387 }