juce/source/src/audio/plugin_host/juce_KnownPluginList.cpp

   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 "../../core/juce_StandardHeader.h"
  27
  28 BEGIN_JUCE_NAMESPACE
  29
  30 #include "juce_KnownPluginList.h"
  31 #include "juce_AudioPluginFormatManager.h"
  32
  33
  34 //==============================================================================
  35 KnownPluginList::KnownPluginList()
  36 {
  37 }
  38
  39 KnownPluginList::~KnownPluginList()
  40 {
  41 }
  42
  43 void KnownPluginList::clear()
  44 {
  45     if (types.size() > 0)
  46     {
  47         types.clear();
  48         sendChangeMessage();
  49     }
  50 }
  51
  52 PluginDescription* KnownPluginList::getTypeForFile (const String& fileOrIdentifier) const
  53 {
  54     for (int i = 0; i < types.size(); ++i)
  55         if (types.getUnchecked(i)->fileOrIdentifier == fileOrIdentifier)
  56             return types.getUnchecked(i);
  57
  58     return nullptr;
  59 }
  60
  61 PluginDescription* KnownPluginList::getTypeForIdentifierString (const String& identifierString) const
  62 {
  63     for (int i = 0; i < types.size(); ++i)
  64         if (types.getUnchecked(i)->createIdentifierString() == identifierString)
  65             return types.getUnchecked(i);
  66
  67     return nullptr;
  68 }
  69
  70 bool KnownPluginList::addType (const PluginDescription& type)
  71 {
  72     for (int i = types.size(); --i >= 0;)
  73     {
  74         if (types.getUnchecked(i)->isDuplicateOf (type))
  75         {
  76             // strange - found a duplicate plugin with different info..
  77             jassert (types.getUnchecked(i)->name == type.name);
  78             jassert (types.getUnchecked(i)->isInstrument == type.isInstrument);
  79
  80             *types.getUnchecked(i) = type;
  81             return false;
  82         }
  83     }
  84
  85     types.add (new PluginDescription (type));
  86     sendChangeMessage();
  87     return true;
  88 }
  89
  90 void KnownPluginList::removeType (const int index)
  91 {
  92     types.remove (index);
  93     sendChangeMessage();
  94 }
  95
  96 namespace
  97 {
  98     Time getPluginFileModTime (const String& fileOrIdentifier)
  99     {
 100         if (fileOrIdentifier.startsWithChar ('/') || fileOrIdentifier[1] == ':')
 101             return File (fileOrIdentifier).getLastModificationTime();
 102
 103         return Time();
 104     }
 105
 106     bool timesAreDifferent (const Time& t1, const Time& t2) noexcept
 107     {
 108         return t1 != t2 || t1 == Time();
 109     }
 110 }
 111
 112 bool KnownPluginList::isListingUpToDate (const String& fileOrIdentifier) const
 113 {
 114     if (getTypeForFile (fileOrIdentifier) == 0)
 115         return false;
 116
 117     for (int i = types.size(); --i >= 0;)
 118     {
 119         const PluginDescription* const d = types.getUnchecked(i);
 120
 121         if (d->fileOrIdentifier == fileOrIdentifier
 122              && timesAreDifferent (d->lastFileModTime, getPluginFileModTime (fileOrIdentifier)))
 123         {
 124             return false;
 125         }
 126     }
 127
 128     return true;
 129 }
 130
 131 bool KnownPluginList::scanAndAddFile (const String& fileOrIdentifier,
 132                                       const bool dontRescanIfAlreadyInList,
 133                                       OwnedArray <PluginDescription>& typesFound,
 134                                       AudioPluginFormat& format)
 135 {
 136     bool addedOne = false;
 137
 138     if (dontRescanIfAlreadyInList
 139          && getTypeForFile (fileOrIdentifier) != nullptr)
 140     {
 141         bool needsRescanning = false;
 142
 143         for (int i = types.size(); --i >= 0;)
 144         {
 145             const PluginDescription* const d = types.getUnchecked(i);
 146
 147             if (d->fileOrIdentifier == fileOrIdentifier)
 148             {
 149                 if (timesAreDifferent (d->lastFileModTime, getPluginFileModTime (fileOrIdentifier)))
 150                     needsRescanning = true;
 151                 else
 152                     typesFound.add (new PluginDescription (*d));
 153             }
 154         }
 155
 156         if (! needsRescanning)
 157             return false;
 158     }
 159
 160     OwnedArray <PluginDescription> found;
 161     format.findAllTypesForFile (found, fileOrIdentifier);
 162
 163     for (int i = 0; i < found.size(); ++i)
 164     {
 165         PluginDescription* const desc = found.getUnchecked(i);
 166         jassert (desc != nullptr);
 167
 168         if (addType (*desc))
 169             addedOne = true;
 170
 171         typesFound.add (new PluginDescription (*desc));
 172     }
 173
 174     return addedOne;
 175 }
 176
 177 void KnownPluginList::scanAndAddDragAndDroppedFiles (const StringArray& files,
 178                                                      OwnedArray <PluginDescription>& typesFound)
 179 {
 180     for (int i = 0; i < files.size(); ++i)
 181     {
 182         for (int j = 0; j < AudioPluginFormatManager::getInstance()->getNumFormats(); ++j)
 183         {
 184             AudioPluginFormat* const format = AudioPluginFormatManager::getInstance()->getFormat (j);
 185
 186             if (scanAndAddFile (files[i], true, typesFound, *format))
 187                 return;
 188         }
 189
 190         const File f (files[i]);
 191
 192         if (f.isDirectory())
 193         {
 194             StringArray s;
 195
 196             {
 197                 Array<File> subFiles;
 198                 f.findChildFiles (subFiles, File::findFilesAndDirectories, false);
 199
 200                 for (int j = 0; j < subFiles.size(); ++j)
 201                     s.add (subFiles.getReference(j).getFullPathName());
 202             }
 203
 204             scanAndAddDragAndDroppedFiles (s, typesFound);
 205         }
 206     }
 207 }
 208
 209 //==============================================================================
 210 class PluginSorter
 211 {
 212 public:
 213     KnownPluginList::SortMethod method;
 214
 215     PluginSorter() noexcept {}
 216
 217     int compareElements (const PluginDescription* const first,
 218                          const PluginDescription* const second) const
 219     {
 220         int diff = 0;
 221
 222         if (method == KnownPluginList::sortByCategory)
 223             diff = first->category.compareLexicographically (second->category);
 224         else if (method == KnownPluginList::sortByManufacturer)
 225             diff = first->manufacturerName.compareLexicographically (second->manufacturerName);
 226         else if (method == KnownPluginList::sortByFileSystemLocation)
 227             diff = first->fileOrIdentifier.replaceCharacter ('\\', '/')
 228                                           .upToLastOccurrenceOf ("/", false, false)
 229                                           .compare (second->fileOrIdentifier.replaceCharacter ('\\', '/')
 230                                                                             .upToLastOccurrenceOf ("/", false, false));
 231
 232         if (diff == 0)
 233             diff = first->name.compareLexicographically (second->name);
 234
 235         return diff;
 236     }
 237 };
 238
 239 void KnownPluginList::sort (const SortMethod method)
 240 {
 241     if (method != defaultOrder)
 242     {
 243         PluginSorter sorter;
 244         sorter.method = method;
 245         types.sort (sorter, true);
 246
 247         sendChangeMessage();
 248     }
 249 }
 250
 251 //==============================================================================
 252 XmlElement* KnownPluginList::createXml() const
 253 {
 254     XmlElement* const e = new XmlElement ("KNOWNPLUGINS");
 255
 256     for (int i = 0; i < types.size(); ++i)
 257         e->addChildElement (types.getUnchecked(i)->createXml());
 258
 259     return e;
 260 }
 261
 262 void KnownPluginList::recreateFromXml (const XmlElement& xml)
 263 {
 264     clear();
 265
 266     if (xml.hasTagName ("KNOWNPLUGINS"))
 267     {
 268         forEachXmlChildElement (xml, e)
 269         {
 270             PluginDescription info;
 271
 272             if (info.loadFromXml (*e))
 273                 addType (info);
 274         }
 275     }
 276 }
 277
 278 //==============================================================================
 279 const int menuIdBase = 0x324503f4;
 280
 281 // This is used to turn a bunch of paths into a nested menu structure.
 282 struct PluginFilesystemTree
 283 {
 284 private:
 285     String folder;
 286     OwnedArray <PluginFilesystemTree> subFolders;
 287     Array <PluginDescription*> plugins;
 288
 289     void addPlugin (PluginDescription* const pd, const String& path)
 290     {
 291         if (path.isEmpty())
 292         {
 293             plugins.add (pd);
 294         }
 295         else
 296         {
 297             const String firstSubFolder (path.upToFirstOccurrenceOf ("/", false, false));
 298             const String remainingPath (path.fromFirstOccurrenceOf ("/", false, false));
 299
 300             for (int i = subFolders.size(); --i >= 0;)
 301             {
 302                 if (subFolders.getUnchecked(i)->folder.equalsIgnoreCase (firstSubFolder))
 303                 {
 304                     subFolders.getUnchecked(i)->addPlugin (pd, remainingPath);
 305                     return;
 306                 }
 307             }
 308
 309             PluginFilesystemTree* const newFolder = new PluginFilesystemTree();
 310             newFolder->folder = firstSubFolder;
 311             subFolders.add (newFolder);
 312
 313             newFolder->addPlugin (pd, remainingPath);
 314         }
 315     }
 316
 317     // removes any deeply nested folders that don't contain any actual plugins
 318     void optimise()
 319     {
 320         for (int i = subFolders.size(); --i >= 0;)
 321         {
 322             PluginFilesystemTree* const sub = subFolders.getUnchecked(i);
 323
 324             sub->optimise();
 325
 326             if (sub->plugins.size() == 0)
 327             {
 328                 for (int j = 0; j < sub->subFolders.size(); ++j)
 329                     subFolders.add (sub->subFolders.getUnchecked(j));
 330
 331                 sub->subFolders.clear (false);
 332                 subFolders.remove (i);
 333             }
 334         }
 335     }
 336
 337 public:
 338     void buildTree (const Array <PluginDescription*>& allPlugins)
 339     {
 340         for (int i = 0; i < allPlugins.size(); ++i)
 341         {
 342             String path (allPlugins.getUnchecked(i)
 343                             ->fileOrIdentifier.replaceCharacter ('\\', '/')
 344                                               .upToLastOccurrenceOf ("/", false, false));
 345
 346             if (path.substring (1, 2) == ":")
 347                 path = path.substring (2);
 348
 349             addPlugin (allPlugins.getUnchecked(i), path);
 350         }
 351
 352         optimise();
 353     }
 354
 355     void addToMenu (PopupMenu& m, const OwnedArray <PluginDescription>& allPlugins) const
 356     {
 357         int i;
 358         for (i = 0; i < subFolders.size(); ++i)
 359         {
 360             const PluginFilesystemTree* const sub = subFolders.getUnchecked(i);
 361
 362             PopupMenu subMenu;
 363             sub->addToMenu (subMenu, allPlugins);
 364
 365 #if JUCE_MAC
 366             // avoid the special AU formatting nonsense on Mac..
 367             m.addSubMenu (sub->folder.fromFirstOccurrenceOf (":", false, false), subMenu);
 368 #else
 369             m.addSubMenu (sub->folder, subMenu);
 370 #endif
 371         }
 372
 373         for (i = 0; i < plugins.size(); ++i)
 374         {
 375             PluginDescription* const plugin = plugins.getUnchecked(i);
 376
 377             m.addItem (allPlugins.indexOf (plugin) + menuIdBase,
 378                        plugin->name, true, false);
 379         }
 380     }
 381 };
 382
 383 //==============================================================================
 384 void KnownPluginList::addToMenu (PopupMenu& menu, const SortMethod sortMethod) const
 385 {
 386     Array <PluginDescription*> sorted;
 387
 388     {
 389         PluginSorter sorter;
 390         sorter.method = sortMethod;
 391
 392         for (int i = 0; i < types.size(); ++i)
 393             sorted.addSorted (sorter, types.getUnchecked(i));
 394     }
 395
 396     if (sortMethod == sortByCategory
 397          || sortMethod == sortByManufacturer)
 398     {
 399         String lastSubMenuName;
 400         PopupMenu sub;
 401
 402         for (int i = 0; i < sorted.size(); ++i)
 403         {
 404             const PluginDescription* const pd = sorted.getUnchecked(i);
 405             String thisSubMenuName (sortMethod == sortByCategory ? pd->category
 406                                                                  : pd->manufacturerName);
 407
 408             if (! thisSubMenuName.containsNonWhitespaceChars())
 409                 thisSubMenuName = "Other";
 410
 411             if (thisSubMenuName != lastSubMenuName)
 412             {
 413                 if (sub.getNumItems() > 0)
 414                 {
 415                     menu.addSubMenu (lastSubMenuName, sub);
 416                     sub.clear();
 417                 }
 418
 419                 lastSubMenuName = thisSubMenuName;
 420             }
 421
 422             sub.addItem (types.indexOf (pd) + menuIdBase, pd->name, true, false);
 423         }
 424
 425         if (sub.getNumItems() > 0)
 426             menu.addSubMenu (lastSubMenuName, sub);
 427     }
 428     else if (sortMethod == sortByFileSystemLocation)
 429     {
 430         PluginFilesystemTree root;
 431         root.buildTree (sorted);
 432         root.addToMenu (menu, types);
 433     }
 434     else
 435     {
 436         for (int i = 0; i < sorted.size(); ++i)
 437         {
 438             const PluginDescription* const pd = sorted.getUnchecked(i);
 439             menu.addItem (types.indexOf (pd) + menuIdBase, pd->name, true, false);
 440         }
 441     }
 442 }
 443
 444 int KnownPluginList::getIndexChosenByMenu (const int menuResultCode) const
 445 {
 446     const int i = menuResultCode - menuIdBase;
 447
 448     return isPositiveAndBelow (i, types.size()) ? i : -1;
 449 }
 450
 451 END_JUCE_NAMESPACE