source/modules/juce_gui_basics/filebrowser/juce_FileTreeComponent.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 //==============================================================================
  30 class FileListTreeItem   : public TreeViewItem,
  31                            private TimeSliceClient,
  32                            private AsyncUpdater,
  33                            private ChangeListener
  34 {
  35 public:
  36     FileListTreeItem (FileTreeComponent& treeComp,
  37                       DirectoryContentsList* parentContents,
  38                       int indexInContents,
  39                       const File& f,
  40                       TimeSliceThread& t)
  41         : file (f),
  42           owner (treeComp),
  43           parentContentsList (parentContents),
  44           indexInContentsList (indexInContents),
  45           subContentsList (nullptr, false),
  46           thread (t)
  47     {
  48         DirectoryContentsList::FileInfo fileInfo;
  49
  50         if (parentContents != nullptr
  51              && parentContents->getFileInfo (indexInContents, fileInfo))
  52         {
  53             fileSize = File::descriptionOfSizeInBytes (fileInfo.fileSize);
  54             modTime = fileInfo.modificationTime.formatted ("%d %b '%y %H:%M");
  55             isDirectory = fileInfo.isDirectory;
  56         }
  57         else
  58         {
  59             isDirectory = true;
  60         }
  61     }
  62
  63     ~FileListTreeItem() override
  64     {
  65         thread.removeTimeSliceClient (this);
  66         clearSubItems();
  67         removeSubContentsList();
  68     }
  69
  70     //==============================================================================
  71     bool mightContainSubItems() override                 { return isDirectory; }
  72     String getUniqueName() const override                { return file.getFullPathName(); }
  73     int getItemHeight() const override                   { return owner.getItemHeight(); }
  74
  75     var getDragSourceDescription() override              { return owner.getDragAndDropDescription(); }
  76
  77     void itemOpennessChanged (bool isNowOpen) override
  78     {
  79         if (isNowOpen)
  80         {
  81             clearSubItems();
  82
  83             isDirectory = file.isDirectory();
  84
  85             if (isDirectory)
  86             {
  87                 if (subContentsList == nullptr && parentContentsList != nullptr)
  88                 {
  89                     auto l = new DirectoryContentsList (parentContentsList->getFilter(), thread);
  90
  91                     l->setDirectory (file,
  92                                      parentContentsList->isFindingDirectories(),
  93                                      parentContentsList->isFindingFiles());
  94
  95                     setSubContentsList (l, true);
  96                 }
  97
  98                 changeListenerCallback (nullptr);
  99             }
 100         }
 101     }
 102
 103     void removeSubContentsList()
 104     {
 105         if (subContentsList != nullptr)
 106         {
 107             subContentsList->removeChangeListener (this);
 108             subContentsList.reset();
 109         }
 110     }
 111
 112     void setSubContentsList (DirectoryContentsList* newList, const bool canDeleteList)
 113     {
 114         removeSubContentsList();
 115
 116         subContentsList = OptionalScopedPointer<DirectoryContentsList> (newList, canDeleteList);
 117         newList->addChangeListener (this);
 118     }
 119
 120     bool selectFile (const File& target)
 121     {
 122         if (file == target)
 123         {
 124             setSelected (true, true);
 125             return true;
 126         }
 127
 128         if (target.isAChildOf (file))
 129         {
 130             setOpen (true);
 131
 132             for (int maxRetries = 500; --maxRetries > 0;)
 133             {
 134                 for (int i = 0; i < getNumSubItems(); ++i)
 135                     if (auto* f = dynamic_cast<FileListTreeItem*> (getSubItem (i)))
 136                         if (f->selectFile (target))
 137                             return true;
 138
 139                 // if we've just opened and the contents are still loading, wait for it..
 140                 if (subContentsList != nullptr && subContentsList->isStillLoading())
 141                 {
 142                     Thread::sleep (10);
 143                     rebuildItemsFromContentList();
 144                 }
 145                 else
 146                 {
 147                     break;
 148                 }
 149             }
 150         }
 151
 152         return false;
 153     }
 154
 155     void changeListenerCallback (ChangeBroadcaster*) override
 156     {
 157         rebuildItemsFromContentList();
 158     }
 159
 160     void rebuildItemsFromContentList()
 161     {
 162         clearSubItems();
 163
 164         if (isOpen() && subContentsList != nullptr)
 165         {
 166             for (int i = 0; i < subContentsList->getNumFiles(); ++i)
 167                 addSubItem (new FileListTreeItem (owner, subContentsList, i,
 168                                                   subContentsList->getFile(i), thread));
 169         }
 170     }
 171
 172     void paintItem (Graphics& g, int width, int height) override
 173     {
 174         ScopedLock lock (iconUpdate);
 175
 176         if (file != File())
 177         {
 178             updateIcon (true);
 179
 180             if (icon.isNull())
 181                 thread.addTimeSliceClient (this);
 182         }
 183
 184         owner.getLookAndFeel().drawFileBrowserRow (g, width, height,
 185                                                    file, file.getFileName(),
 186                                                    &icon, fileSize, modTime,
 187                                                    isDirectory, isSelected(),
 188                                                    indexInContentsList, owner);
 189     }
 190
 191     String getAccessibilityName() override
 192     {
 193         return file.getFileName();
 194     }
 195
 196     void itemClicked (const MouseEvent& e) override
 197     {
 198         owner.sendMouseClickMessage (file, e);
 199     }
 200
 201     void itemDoubleClicked (const MouseEvent& e) override
 202     {
 203         TreeViewItem::itemDoubleClicked (e);
 204
 205         owner.sendDoubleClickMessage (file);
 206     }
 207
 208     void itemSelectionChanged (bool) override
 209     {
 210         owner.sendSelectionChangeMessage();
 211     }
 212
 213     int useTimeSlice() override
 214     {
 215         updateIcon (false);
 216         return -1;
 217     }
 218
 219     void handleAsyncUpdate() override
 220     {
 221         owner.repaint();
 222     }
 223
 224     const File file;
 225
 226 private:
 227     FileTreeComponent& owner;
 228     DirectoryContentsList* parentContentsList;
 229     int indexInContentsList;
 230     OptionalScopedPointer<DirectoryContentsList> subContentsList;
 231     bool isDirectory;
 232     TimeSliceThread& thread;
 233     CriticalSection iconUpdate;
 234     Image icon;
 235     String fileSize, modTime;
 236
 237     void updateIcon (const bool onlyUpdateIfCached)
 238     {
 239         if (icon.isNull())
 240         {
 241             auto hashCode = (file.getFullPathName() + "_iconCacheSalt").hashCode();
 242             auto im = ImageCache::getFromHashCode (hashCode);
 243
 244             if (im.isNull() && ! onlyUpdateIfCached)
 245             {
 246                 im = juce_createIconForFile (file);
 247
 248                 if (im.isValid())
 249                     ImageCache::addImageToCache (im, hashCode);
 250             }
 251
 252             if (im.isValid())
 253             {
 254                 {
 255                     ScopedLock lock (iconUpdate);
 256                     icon = im;
 257                 }
 258
 259                 triggerAsyncUpdate();
 260             }
 261         }
 262     }
 263
 264     JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (FileListTreeItem)
 265 };
 266
 267 //==============================================================================
 268 FileTreeComponent::FileTreeComponent (DirectoryContentsList& listToShow)
 269     : DirectoryContentsDisplayComponent (listToShow),
 270       itemHeight (22)
 271 {
 272     setRootItemVisible (false);
 273     refresh();
 274 }
 275
 276 FileTreeComponent::~FileTreeComponent()
 277 {
 278     deleteRootItem();
 279 }
 280
 281 void FileTreeComponent::refresh()
 282 {
 283     deleteRootItem();
 284
 285     auto root = new FileListTreeItem (*this, nullptr, 0, directoryContentsList.getDirectory(),
 286                                       directoryContentsList.getTimeSliceThread());
 287
 288     root->setSubContentsList (&directoryContentsList, false);
 289     setRootItem (root);
 290 }
 291
 292 //==============================================================================
 293 File FileTreeComponent::getSelectedFile (const int index) const
 294 {
 295     if (auto* item = dynamic_cast<const FileListTreeItem*> (getSelectedItem (index)))
 296         return item->file;
 297
 298     return {};
 299 }
 300
 301 void FileTreeComponent::deselectAllFiles()
 302 {
 303     clearSelectedItems();
 304 }
 305
 306 void FileTreeComponent::scrollToTop()
 307 {
 308     getViewport()->getVerticalScrollBar().setCurrentRangeStart (0);
 309 }
 310
 311 void FileTreeComponent::setDragAndDropDescription (const String& description)
 312 {
 313     dragAndDropDescription = description;
 314 }
 315
 316 void FileTreeComponent::setSelectedFile (const File& target)
 317 {
 318     if (auto* t = dynamic_cast<FileListTreeItem*> (getRootItem()))
 319         if (! t->selectFile (target))
 320             clearSelectedItems();
 321 }
 322
 323 void FileTreeComponent::setItemHeight (int newHeight)
 324 {
 325     if (itemHeight != newHeight)
 326     {
 327         itemHeight = newHeight;
 328
 329         if (auto* root = getRootItem())
 330             root->treeHasChanged();
 331     }
 332 }
 333
 334 } // namespace juce