source/modules/juce_audio_processors/scanning/juce_PluginListComponent.cpp

   1 /*
   2   ==============================================================================
   3
   4    This file is part of the JUCE library.
   5    Copyright (c) 2022 - Raw Material Software Limited
   6
   7    JUCE is an open source library subject to commercial or open-source
   8    licensing.
   9
  10    By using JUCE, you agree to the terms of both the JUCE 7 End-User License
  11    Agreement and JUCE Privacy Policy.
  12
  13    End User License Agreement: www.juce.com/juce-7-licence
  14    Privacy Policy: www.juce.com/juce-privacy-policy
  15
  16    Or: You may also use this code under the terms of the GPL v3 (see
  17    www.gnu.org/licenses).
  18
  19    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER
  20    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE
  21    DISCLAIMED.
  22
  23   ==============================================================================
  24 */
  25
  26 namespace juce
  27 {
  28
  29 class PluginListComponent::TableModel  : public TableListBoxModel
  30 {
  31 public:
  32     TableModel (PluginListComponent& c, KnownPluginList& l)  : owner (c), list (l) {}
  33
  34     int getNumRows() override
  35     {
  36         return list.getNumTypes() + list.getBlacklistedFiles().size();
  37     }
  38
  39     void paintRowBackground (Graphics& g, int /*rowNumber*/, int /*width*/, int /*height*/, bool rowIsSelected) override
  40     {
  41         const auto defaultColour = owner.findColour (ListBox::backgroundColourId);
  42         const auto c = rowIsSelected ? defaultColour.interpolatedWith (owner.findColour (ListBox::textColourId), 0.5f)
  43                                      : defaultColour;
  44
  45         g.fillAll (c);
  46     }
  47
  48     enum
  49     {
  50         nameCol = 1,
  51         typeCol = 2,
  52         categoryCol = 3,
  53         manufacturerCol = 4,
  54         descCol = 5
  55     };
  56
  57     void paintCell (Graphics& g, int row, int columnId, int width, int height, bool /*rowIsSelected*/) override
  58     {
  59         String text;
  60         bool isBlacklisted = row >= list.getNumTypes();
  61
  62         if (isBlacklisted)
  63         {
  64             if (columnId == nameCol)
  65                 text = list.getBlacklistedFiles() [row - list.getNumTypes()];
  66             else if (columnId == descCol)
  67                 text = TRANS("Deactivated after failing to initialise correctly");
  68         }
  69         else
  70         {
  71             auto desc = list.getTypes()[row];
  72
  73             switch (columnId)
  74             {
  75                 case nameCol:         text = desc.name; break;
  76                 case typeCol:         text = desc.pluginFormatName; break;
  77                 case categoryCol:     text = desc.category.isNotEmpty() ? desc.category : "-"; break;
  78                 case manufacturerCol: text = desc.manufacturerName; break;
  79                 case descCol:         text = getPluginDescription (desc); break;
  80
  81                 default: jassertfalse; break;
  82             }
  83         }
  84
  85         if (text.isNotEmpty())
  86         {
  87             const auto defaultTextColour = owner.findColour (ListBox::textColourId);
  88             g.setColour (isBlacklisted ? Colours::red
  89                                        : columnId == nameCol ? defaultTextColour
  90                                                              : defaultTextColour.interpolatedWith (Colours::transparentBlack, 0.3f));
  91             g.setFont (Font ((float) height * 0.7f, Font::bold));
  92             g.drawFittedText (text, 4, 0, width - 6, height, Justification::centredLeft, 1, 0.9f);
  93         }
  94     }
  95
  96     void cellClicked (int rowNumber, int columnId, const juce::MouseEvent& e) override
  97     {
  98         TableListBoxModel::cellClicked (rowNumber, columnId, e);
  99
 100         if (rowNumber >= 0 && rowNumber < getNumRows() && e.mods.isPopupMenu())
 101             owner.createMenuForRow (rowNumber).showMenuAsync (PopupMenu::Options().withDeletionCheck (owner));
 102     }
 103
 104     void deleteKeyPressed (int) override
 105     {
 106         owner.removeSelectedPlugins();
 107     }
 108
 109     void sortOrderChanged (int newSortColumnId, bool isForwards) override
 110     {
 111         switch (newSortColumnId)
 112         {
 113             case nameCol:         list.sort (KnownPluginList::sortAlphabetically, isForwards); break;
 114             case typeCol:         list.sort (KnownPluginList::sortByFormat, isForwards); break;
 115             case categoryCol:     list.sort (KnownPluginList::sortByCategory, isForwards); break;
 116             case manufacturerCol: list.sort (KnownPluginList::sortByManufacturer, isForwards); break;
 117             case descCol:         break;
 118
 119             default: jassertfalse; break;
 120         }
 121     }
 122
 123     static String getPluginDescription (const PluginDescription& desc)
 124     {
 125         StringArray items;
 126
 127         if (desc.descriptiveName != desc.name)
 128             items.add (desc.descriptiveName);
 129
 130         items.add (desc.version);
 131
 132         items.removeEmptyStrings();
 133         return items.joinIntoString (" - ");
 134     }
 135
 136     PluginListComponent& owner;
 137     KnownPluginList& list;
 138
 139     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (TableModel)
 140 };
 141
 142 //==============================================================================
 143 PluginListComponent::PluginListComponent (AudioPluginFormatManager& manager, KnownPluginList& listToEdit,
 144                                           const File& deadMansPedal, PropertiesFile* const props,
 145                                           bool allowPluginsWhichRequireAsynchronousInstantiation)
 146     : formatManager (manager),
 147       list (listToEdit),
 148       deadMansPedalFile (deadMansPedal),
 149       optionsButton ("Options..."),
 150       propertiesToUse (props),
 151       allowAsync (allowPluginsWhichRequireAsynchronousInstantiation),
 152       numThreads (allowAsync ? 1 : 0)
 153 {
 154     tableModel.reset (new TableModel (*this, listToEdit));
 155
 156     TableHeaderComponent& header = table.getHeader();
 157
 158     header.addColumn (TRANS("Name"),         TableModel::nameCol,         200, 100, 700, TableHeaderComponent::defaultFlags | TableHeaderComponent::sortedForwards);
 159     header.addColumn (TRANS("Format"),       TableModel::typeCol,         80, 80, 80,    TableHeaderComponent::notResizable);
 160     header.addColumn (TRANS("Category"),     TableModel::categoryCol,     100, 100, 200);
 161     header.addColumn (TRANS("Manufacturer"), TableModel::manufacturerCol, 200, 100, 300);
 162     header.addColumn (TRANS("Description"),  TableModel::descCol,         300, 100, 500, TableHeaderComponent::notSortable);
 163
 164     table.setHeaderHeight (22);
 165     table.setRowHeight (20);
 166     table.setModel (tableModel.get());
 167     table.setMultipleSelectionEnabled (true);
 168     addAndMakeVisible (table);
 169
 170     addAndMakeVisible (optionsButton);
 171     optionsButton.onClick = [this]
 172     {
 173         createOptionsMenu().showMenuAsync (PopupMenu::Options()
 174                                               .withDeletionCheck (*this)
 175                                               .withTargetComponent (optionsButton));
 176     };
 177
 178     optionsButton.setTriggeredOnMouseDown (true);
 179
 180     setSize (400, 600);
 181     list.addChangeListener (this);
 182     updateList();
 183     table.getHeader().reSortTable();
 184
 185     PluginDirectoryScanner::applyBlacklistingsFromDeadMansPedal (list, deadMansPedalFile);
 186     deadMansPedalFile.deleteFile();
 187 }
 188
 189 PluginListComponent::~PluginListComponent()
 190 {
 191     list.removeChangeListener (this);
 192 }
 193
 194 void PluginListComponent::setOptionsButtonText (const String& newText)
 195 {
 196     optionsButton.setButtonText (newText);
 197     resized();
 198 }
 199
 200 void PluginListComponent::setScanDialogText (const String& title, const String& content)
 201 {
 202     dialogTitle = title;
 203     dialogText = content;
 204 }
 205
 206 void PluginListComponent::setNumberOfThreadsForScanning (int num)
 207 {
 208     numThreads = num;
 209 }
 210
 211 void PluginListComponent::resized()
 212 {
 213     auto r = getLocalBounds().reduced (2);
 214
 215     if (optionsButton.isVisible())
 216     {
 217         optionsButton.setBounds (r.removeFromBottom (24));
 218         optionsButton.changeWidthToFitText (24);
 219         r.removeFromBottom (3);
 220     }
 221
 222     table.setBounds (r);
 223 }
 224
 225 void PluginListComponent::changeListenerCallback (ChangeBroadcaster*)
 226 {
 227     table.getHeader().reSortTable();
 228     updateList();
 229 }
 230
 231 void PluginListComponent::updateList()
 232 {
 233     table.updateContent();
 234     table.repaint();
 235 }
 236
 237 void PluginListComponent::removeSelectedPlugins()
 238 {
 239     auto selected = table.getSelectedRows();
 240
 241     for (int i = table.getNumRows(); --i >= 0;)
 242         if (selected.contains (i))
 243             removePluginItem (i);
 244 }
 245
 246 void PluginListComponent::setTableModel (TableListBoxModel* model)
 247 {
 248     table.setModel (nullptr);
 249     tableModel.reset (model);
 250     table.setModel (tableModel.get());
 251
 252     table.getHeader().reSortTable();
 253     table.updateContent();
 254     table.repaint();
 255 }
 256
 257 static bool canShowFolderForPlugin (KnownPluginList& list, int index)
 258 {
 259     return File::createFileWithoutCheckingPath (list.getTypes()[index].fileOrIdentifier).exists();
 260 }
 261
 262 static void showFolderForPlugin (KnownPluginList& list, int index)
 263 {
 264     if (canShowFolderForPlugin (list, index))
 265         File (list.getTypes()[index].fileOrIdentifier).revealToUser();
 266 }
 267
 268 void PluginListComponent::removeMissingPlugins()
 269 {
 270     auto types = list.getTypes();
 271
 272     for (int i = types.size(); --i >= 0;)
 273     {
 274         auto type = types.getUnchecked (i);
 275
 276         if (! formatManager.doesPluginStillExist (type))
 277             list.removeType (type);
 278     }
 279 }
 280
 281 void PluginListComponent::removePluginItem (int index)
 282 {
 283     if (index < list.getNumTypes())
 284         list.removeType (list.getTypes()[index]);
 285     else
 286         list.removeFromBlacklist (list.getBlacklistedFiles() [index - list.getNumTypes()]);
 287 }
 288
 289 PopupMenu PluginListComponent::createOptionsMenu()
 290 {
 291     PopupMenu menu;
 292     menu.addItem (PopupMenu::Item (TRANS("Clear list"))
 293                     .setAction ([this] { list.clear(); }));
 294
 295     menu.addSeparator();
 296
 297     for (auto format : formatManager.getFormats())
 298         if (format->canScanForPlugins())
 299             menu.addItem (PopupMenu::Item ("Remove all " + format->getName() + " plug-ins")
 300                             .setEnabled (! list.getTypesForFormat (*format).isEmpty())
 301                             .setAction ([this, format]
 302                                         {
 303                                             for (auto& pd : list.getTypesForFormat (*format))
 304                                                 list.removeType (pd);
 305                                         }));
 306
 307     menu.addSeparator();
 308
 309     menu.addItem (PopupMenu::Item (TRANS("Remove selected plug-in from list"))
 310                     .setEnabled (table.getNumSelectedRows() > 0)
 311                     .setAction ([this] { removeSelectedPlugins(); }));
 312
 313     menu.addItem (PopupMenu::Item (TRANS("Remove any plug-ins whose files no longer exist"))
 314                     .setAction ([this] { removeMissingPlugins(); }));
 315
 316     menu.addSeparator();
 317
 318     auto selectedRow = table.getSelectedRow();
 319
 320     menu.addItem (PopupMenu::Item (TRANS("Show folder containing selected plug-in"))
 321                     .setEnabled (canShowFolderForPlugin (list, selectedRow))
 322                     .setAction ([this, selectedRow] { showFolderForPlugin (list, selectedRow); }));
 323
 324     menu.addSeparator();
 325
 326     for (auto format : formatManager.getFormats())
 327         if (format->canScanForPlugins())
 328             menu.addItem (PopupMenu::Item ("Scan for new or updated " + format->getName() + " plug-ins")
 329                             .setAction ([this, format]  { scanFor (*format); }));
 330
 331     return menu;
 332 }
 333
 334 PopupMenu PluginListComponent::createMenuForRow (int rowNumber)
 335 {
 336     PopupMenu menu;
 337
 338     if (rowNumber >= 0 && rowNumber < tableModel->getNumRows())
 339     {
 340         menu.addItem (PopupMenu::Item (TRANS("Remove plug-in from list"))
 341                         .setAction ([this, rowNumber] { removePluginItem (rowNumber); }));
 342
 343         menu.addItem (PopupMenu::Item (TRANS("Show folder containing plug-in"))
 344                         .setEnabled (canShowFolderForPlugin (list, rowNumber))
 345                         .setAction ([this, rowNumber] { showFolderForPlugin (list, rowNumber); }));
 346     }
 347
 348     return menu;
 349 }
 350
 351 bool PluginListComponent::isInterestedInFileDrag (const StringArray& /*files*/)
 352 {
 353     return true;
 354 }
 355
 356 void PluginListComponent::filesDropped (const StringArray& files, int, int)
 357 {
 358     OwnedArray<PluginDescription> typesFound;
 359     list.scanAndAddDragAndDroppedFiles (formatManager, files, typesFound);
 360 }
 361
 362 FileSearchPath PluginListComponent::getLastSearchPath (PropertiesFile& properties, AudioPluginFormat& format)
 363 {
 364     auto key = "lastPluginScanPath_" + format.getName();
 365
 366     if (properties.containsKey (key) && properties.getValue (key, {}).trim().isEmpty())
 367         properties.removeValue (key);
 368
 369     return FileSearchPath (properties.getValue (key, format.getDefaultLocationsToSearch().toString()));
 370 }
 371
 372 void PluginListComponent::setLastSearchPath (PropertiesFile& properties, AudioPluginFormat& format,
 373                                              const FileSearchPath& newPath)
 374 {
 375     auto key = "lastPluginScanPath_" + format.getName();
 376
 377     if (newPath.getNumPaths() == 0)
 378         properties.removeValue (key);
 379     else
 380         properties.setValue (key, newPath.toString());
 381 }
 382
 383 //==============================================================================
 384 class PluginListComponent::Scanner    : private Timer
 385 {
 386 public:
 387     Scanner (PluginListComponent& plc, AudioPluginFormat& format, const StringArray& filesOrIdentifiers,
 388              PropertiesFile* properties, bool allowPluginsWhichRequireAsynchronousInstantiation, int threads,
 389              const String& title, const String& text)
 390         : owner (plc),
 391           formatToScan (format),
 392           filesOrIdentifiersToScan (filesOrIdentifiers),
 393           propertiesToUse (properties),
 394           pathChooserWindow (TRANS("Select folders to scan..."), String(), MessageBoxIconType::NoIcon),
 395           progressWindow (title, text, MessageBoxIconType::NoIcon),
 396           numThreads (threads),
 397           allowAsync (allowPluginsWhichRequireAsynchronousInstantiation)
 398     {
 399         const auto blacklisted = owner.list.getBlacklistedFiles();
 400         initiallyBlacklistedFiles = std::set<String> (blacklisted.begin(), blacklisted.end());
 401
 402         FileSearchPath path (formatToScan.getDefaultLocationsToSearch());
 403
 404         // You need to use at least one thread when scanning plug-ins asynchronously
 405         jassert (! allowAsync || (numThreads > 0));
 406
 407         // If the filesOrIdentifiersToScan argument isn't empty, we should only scan these
 408         // If the path is empty, then paths aren't used for this format.
 409         if (filesOrIdentifiersToScan.isEmpty() && path.getNumPaths() > 0)
 410         {
 411            #if ! JUCE_IOS
 412             if (propertiesToUse != nullptr)
 413                 path = getLastSearchPath (*propertiesToUse, formatToScan);
 414            #endif
 415
 416             pathList.setSize (500, 300);
 417             pathList.setPath (path);
 418
 419             pathChooserWindow.addCustomComponent (&pathList);
 420             pathChooserWindow.addButton (TRANS("Scan"),   1, KeyPress (KeyPress::returnKey));
 421             pathChooserWindow.addButton (TRANS("Cancel"), 0, KeyPress (KeyPress::escapeKey));
 422
 423             pathChooserWindow.enterModalState (true,
 424                                                ModalCallbackFunction::forComponent (startScanCallback,
 425                                                                                     &pathChooserWindow, this),
 426                                                false);
 427         }
 428         else
 429         {
 430             startScan();
 431         }
 432     }
 433
 434     ~Scanner() override
 435     {
 436         if (pool != nullptr)
 437         {
 438             pool->removeAllJobs (true, 60000);
 439             pool.reset();
 440         }
 441     }
 442
 443 private:
 444     PluginListComponent& owner;
 445     AudioPluginFormat& formatToScan;
 446     StringArray filesOrIdentifiersToScan;
 447     PropertiesFile* propertiesToUse;
 448     std::unique_ptr<PluginDirectoryScanner> scanner;
 449     AlertWindow pathChooserWindow, progressWindow;
 450     FileSearchPathListComponent pathList;
 451     String pluginBeingScanned;
 452     double progress = 0;
 453     const int numThreads;
 454     bool allowAsync, timerReentrancyCheck = false;
 455     std::atomic<bool> finished { false };
 456     std::unique_ptr<ThreadPool> pool;
 457     std::set<String> initiallyBlacklistedFiles;
 458
 459     static void startScanCallback (int result, AlertWindow* alert, Scanner* scanner)
 460     {
 461         if (alert != nullptr && scanner != nullptr)
 462         {
 463             if (result != 0)
 464                 scanner->warnUserAboutStupidPaths();
 465             else
 466                 scanner->finishedScan();
 467         }
 468     }
 469
 470     // Try to dissuade people from to scanning their entire C: drive, or other system folders.
 471     void warnUserAboutStupidPaths()
 472     {
 473         for (int i = 0; i < pathList.getPath().getNumPaths(); ++i)
 474         {
 475             auto f = pathList.getPath()[i];
 476
 477             if (isStupidPath (f))
 478             {
 479                 AlertWindow::showOkCancelBox (MessageBoxIconType::WarningIcon,
 480                                               TRANS("Plugin Scanning"),
 481                                               TRANS("If you choose to scan folders that contain non-plugin files, "
 482                                                     "then scanning may take a long time, and can cause crashes when "
 483                                                     "attempting to load unsuitable files.")
 484                                                 + newLine
 485                                                 + TRANS ("Are you sure you want to scan the folder \"XYZ\"?")
 486                                                    .replace ("XYZ", f.getFullPathName()),
 487                                               TRANS ("Scan"),
 488                                               String(),
 489                                               nullptr,
 490                                               ModalCallbackFunction::create (warnAboutStupidPathsCallback, this));
 491                 return;
 492             }
 493         }
 494
 495         startScan();
 496     }
 497
 498     static bool isStupidPath (const File& f)
 499     {
 500         Array<File> roots;
 501         File::findFileSystemRoots (roots);
 502
 503         if (roots.contains (f))
 504             return true;
 505
 506         File::SpecialLocationType pathsThatWouldBeStupidToScan[]
 507             = { File::globalApplicationsDirectory,
 508                 File::userHomeDirectory,
 509                 File::userDocumentsDirectory,
 510                 File::userDesktopDirectory,
 511                 File::tempDirectory,
 512                 File::userMusicDirectory,
 513                 File::userMoviesDirectory,
 514                 File::userPicturesDirectory };
 515
 516         for (auto location : pathsThatWouldBeStupidToScan)
 517         {
 518             auto sillyFolder = File::getSpecialLocation (location);
 519
 520             if (f == sillyFolder || sillyFolder.isAChildOf (f))
 521                 return true;
 522         }
 523
 524         return false;
 525     }
 526
 527     static void warnAboutStupidPathsCallback (int result, Scanner* scanner)
 528     {
 529         if (result != 0)
 530             scanner->startScan();
 531         else
 532             scanner->finishedScan();
 533     }
 534
 535     void startScan()
 536     {
 537         pathChooserWindow.setVisible (false);
 538
 539         scanner.reset (new PluginDirectoryScanner (owner.list, formatToScan, pathList.getPath(),
 540                                                    true, owner.deadMansPedalFile, allowAsync));
 541
 542         if (! filesOrIdentifiersToScan.isEmpty())
 543         {
 544             scanner->setFilesOrIdentifiersToScan (filesOrIdentifiersToScan);
 545         }
 546         else if (propertiesToUse != nullptr)
 547         {
 548             setLastSearchPath (*propertiesToUse, formatToScan, pathList.getPath());
 549             propertiesToUse->saveIfNeeded();
 550         }
 551
 552         progressWindow.addButton (TRANS("Cancel"), 0, KeyPress (KeyPress::escapeKey));
 553         progressWindow.addProgressBarComponent (progress);
 554         progressWindow.enterModalState();
 555
 556         if (numThreads > 0)
 557         {
 558             pool.reset (new ThreadPool (numThreads));
 559
 560             for (int i = numThreads; --i >= 0;)
 561                 pool->addJob (new ScanJob (*this), true);
 562         }
 563
 564         startTimer (20);
 565     }
 566
 567     void finishedScan()
 568     {
 569         const auto blacklisted = owner.list.getBlacklistedFiles();
 570         std::set<String> allBlacklistedFiles (blacklisted.begin(), blacklisted.end());
 571
 572         std::vector<String> newBlacklistedFiles;
 573         std::set_difference (allBlacklistedFiles.begin(), allBlacklistedFiles.end(),
 574                              initiallyBlacklistedFiles.begin(), initiallyBlacklistedFiles.end(),
 575                              std::back_inserter (newBlacklistedFiles));
 576
 577         owner.scanFinished (scanner != nullptr ? scanner->getFailedFiles() : StringArray(),
 578                             newBlacklistedFiles);
 579     }
 580
 581     void timerCallback() override
 582     {
 583         if (timerReentrancyCheck)
 584             return;
 585
 586         progress = scanner->getProgress();
 587
 588         if (pool == nullptr)
 589         {
 590             const ScopedValueSetter<bool> setter (timerReentrancyCheck, true);
 591
 592             if (doNextScan())
 593                 startTimer (20);
 594         }
 595
 596         if (! progressWindow.isCurrentlyModal())
 597             finished = true;
 598
 599         if (finished)
 600             finishedScan();
 601         else
 602             progressWindow.setMessage (TRANS("Testing") + ":\n\n" + pluginBeingScanned);
 603     }
 604
 605     bool doNextScan()
 606     {
 607         if (scanner->scanNextFile (true, pluginBeingScanned))
 608             return true;
 609
 610         finished = true;
 611         return false;
 612     }
 613
 614     struct ScanJob  : public ThreadPoolJob
 615     {
 616         ScanJob (Scanner& s)  : ThreadPoolJob ("pluginscan"), scanner (s) {}
 617
 618         JobStatus runJob()
 619         {
 620             while (scanner.doNextScan() && ! shouldExit())
 621             {}
 622
 623             return jobHasFinished;
 624         }
 625
 626         Scanner& scanner;
 627
 628         JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (ScanJob)
 629     };
 630
 631     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (Scanner)
 632 };
 633
 634 void PluginListComponent::scanFor (AudioPluginFormat& format)
 635 {
 636     scanFor (format, StringArray());
 637 }
 638
 639 void PluginListComponent::scanFor (AudioPluginFormat& format, const StringArray& filesOrIdentifiersToScan)
 640 {
 641     currentScanner.reset (new Scanner (*this, format, filesOrIdentifiersToScan, propertiesToUse, allowAsync, numThreads,
 642                                        dialogTitle.isNotEmpty() ? dialogTitle : TRANS("Scanning for plug-ins..."),
 643                                        dialogText.isNotEmpty()  ? dialogText  : TRANS("Searching for all possible plug-in files...")));
 644 }
 645
 646 bool PluginListComponent::isScanning() const noexcept
 647 {
 648     return currentScanner != nullptr;
 649 }
 650
 651 void PluginListComponent::scanFinished (const StringArray& failedFiles,
 652                                         const std::vector<String>& newBlacklistedFiles)
 653 {
 654     StringArray warnings;
 655
 656     const auto addWarningText = [&warnings] (const auto& range, const auto& prefix)
 657     {
 658         if (range.size() == 0)
 659             return;
 660
 661         StringArray names;
 662
 663         for (auto& f : range)
 664             names.add (File::createFileWithoutCheckingPath (f).getFileName());
 665
 666         warnings.add (prefix + ":\n\n" + names.joinIntoString (", "));
 667     };
 668
 669     addWarningText (newBlacklistedFiles,  TRANS ("The following files encountered fatal errors during validation"));
 670     addWarningText (failedFiles,          TRANS ("The following files appeared to be plugin files, but failed to load correctly"));
 671
 672     currentScanner.reset(); // mustn't delete this before using the failed files array
 673
 674     if (! warnings.isEmpty())
 675         AlertWindow::showMessageBoxAsync (MessageBoxIconType::InfoIcon,
 676                                           TRANS("Scan complete"),
 677                                           warnings.joinIntoString ("\n\n"));
 678 }
 679
 680 } // namespace juce