#include "scenebrowser.h"

// Tnz6 includes

#include "dvdirtreeview.h"

#include "filebrowser.h"

#include "filebrowsermodel.h"

#include "fileselection.h"

#include "filmstripselection.h"

#include "castselection.h"

#include "menubarcommandids.h"

#include "floatingpanelcommand.h"

#include "iocommand.h"

#include "history.h"

#include "tapp.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/icongenerator.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/gutil.h"

#include "toonzqt/trepetitionguard.h"

// TnzLib includes

#include "toonz/tscenehandle.h"

#include "toonz/toonzscene.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshsoundlevel.h"

#include "toonz/tproject.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/namebuilder.h"

#include "toonz/toonzimageutils.h"

#include "toonz/preferences.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "tsystem.h"

#include "tconvert.h"

#include "tfiletype.h"

#include "tlevel_io.h"

// Qt includes

#include <qdrag></qdrag>

#include <qdragenterevent></qdragenterevent>

#include <qdragmoveevent></qdragmoveevent>

#include <qdropevent></qdropevent>

#include <qdragleaveevent></qdragleaveevent>

#include <qboxlayout></qboxlayout>

#include <qlabel></qlabel>

#include <qbytearray></qbytearray>

#include <qmenu></qmenu>

#include <qdatetime></qdatetime>

#include <qinputdialog></qinputdialog>

#include <qdesktopservices></qdesktopservices>

#include <qdirmodel></qdirmodel>

#include <qdir></qdir>

#include <qpixmap></qpixmap>

#include <qurl></qurl>

#include <qregexp></qregexp>

#include <qscrollbar></qscrollbar>

#include <qmap></qmap>

#include <qpushbutton></qpushbutton>

#include <qpalette></qpalette>

#include <qcheckbox></qcheckbox>

#include <qmutex></qmutex>

#include <qmutexlocker></qmutexlocker>

#include <qmessagebox></qmessagebox>

#include <qapplication></qapplication>

#include <qformlayout></qformlayout>

#include <qmainwindow></qmainwindow>

#include <qlineedit></qlineedit>

#include <qtreewidgetitem></qtreewidgetitem>

#include <qsplitter></qsplitter>

#include <qfilesystemwatcher></qfilesystemwatcher>

// tcg includes

#include "tcg/boost/range_utility.h"

#include "tcg/boost/permuted_range.h"

// boost includes

#include <boost bind.hpp=""></boost>

#include <boost counting_iterator.hpp="" iterator=""></boost>

#include <boost adaptor="" filtered.hpp="" range=""></boost>

#include <boost adaptor="" range="" transformed.hpp=""></boost>

namespace ba = boost::adaptors;

using namespace DVGui;

//=============================================================================

//      Local namespace

//=============================================================================

namespace {

std::set<scenebrowser *=""> activePreproductionBoards;</scenebrowser>

//std::map<tfilepath, fcdata=""> frameCountMap;</tfilepath,>

//QMutex frameCountMapMutex;

QMutex levelFileMutex;

}  // namespace

inline bool isMultipleFrameType(std::string type) {

  return (type == "tlv" || type == "tzl" || type == "pli" || type == "mov" ||

          type == "avi" || type == "3gp" || type == "gif" || type == "mp4" ||

          type == "webm");

}

//=============================================================================

//

// SceneBrowserButtonBar

//

//-----------------------------------------------------------------------------

SceneBrowserButtonBar::SceneBrowserButtonBar(DvItemViewer *itemViewer,

                                             QWidget *parent)

    : QToolBar(parent) {

  setToolButtonStyle(Qt::ToolButtonTextBesideIcon);

  setIconSize(QSize(17, 17));

  setObjectName("buttonBar");

  // buttonBar->setIconSize(QSize(10,10));

  QIcon newFolderIcon = createQIcon("newfolder");

  QAction *newScene  = new QAction(newFolderIcon, tr("Add new scene"), this);

  newScene->setIconText(tr("Add scene"));

  addAction(newScene);

  //addSeparator();

  connect(newScene, SIGNAL(triggered()), SIGNAL(newScene()));

}

//=============================================================================

// SceneBrowser

//-----------------------------------------------------------------------------

#if QT_VERSION >= 0x050500

SceneBrowser::SceneBrowser(QWidget *parent, Qt::WindowFlags flags,

                         bool noContextMenu, bool multiSelectionEnabled)

#else

SceneBrowser::SceneBrowser(QWidget *parent, Qt::WFlags flags, bool noContextMenu,

                         bool multiSelectionEnabled)

#endif

    : QFrame(parent), m_folderName(0), m_itemViewer(0) {

  // style sheet

  setObjectName("SceneBrowser");

  setFrameStyle(QFrame::StyledPanel);

  //m_mainSplitter      = new QSplitter(this);

  m_folderTreeView    = new DvDirTreeView(this);

  QFrame *box         = new QFrame(this);

  QLabel *folderLabel = new QLabel(tr("Folder: "), this);

  m_folderName        = new QLineEdit();

  m_itemViewer = new DvItemViewer(box, noContextMenu, multiSelectionEnabled,

                                  DvItemViewer::Browser);

  DvItemViewerTitleBar *titleBar = new DvItemViewerTitleBar(m_itemViewer, box);

  SceneBrowserButtonBar *buttonBar =

      new SceneBrowserButtonBar(m_itemViewer, box);

  DvItemViewerPanel *viewerPanel = m_itemViewer->getPanel();

  viewerPanel->setThumbnailsView();

  viewerPanel->addColumn(DvItemListModel::FileType, 50);

  viewerPanel->addColumn(DvItemListModel::FrameCount, 50);

  viewerPanel->addColumn(DvItemListModel::FileSize, 50);

  viewerPanel->addColumn(DvItemListModel::CreationDate, 130);

  viewerPanel->addColumn(DvItemListModel::ModifiedDate, 130);

  if (Preferences::instance()->isSVNEnabled())

    viewerPanel->addColumn(DvItemListModel::VersionControlStatus, 120);

  viewerPanel->setSelection(new FileSelection());

  DVItemViewPlayDelegate *itemViewPlayDelegate =

      new DVItemViewPlayDelegate(viewerPanel);

  viewerPanel->setItemViewPlayDelegate(itemViewPlayDelegate);

  //m_mainSplitter->setObjectName("SceneBrowserSplitter");

  m_folderTreeView->setObjectName("DirTreeView");

  box->setObjectName("castFrame");

  box->setFrameStyle(QFrame::StyledPanel);

  m_itemViewer->setModel(this);

  // layout

  QVBoxLayout *mainLayout = new QVBoxLayout();

  mainLayout->setMargin(3);

  mainLayout->setSpacing(2);

  {

    mainLayout->addWidget(buttonBar);

    QHBoxLayout *folderLay = new QHBoxLayout();

    folderLay->setMargin(0);

    folderLay->setSpacing(0);

    {

      folderLay->addWidget(folderLabel, 0);

      folderLay->addWidget(m_folderName, 1);

    }

    mainLayout->addLayout(folderLay, 0);

    //m_mainSplitter->addWidget(m_folderTreeView);

    QVBoxLayout *boxLayout = new QVBoxLayout(box);

    boxLayout->setMargin(0);

    boxLayout->setSpacing(0);

    {

      boxLayout->addWidget(titleBar, 0);

      boxLayout->addWidget(m_itemViewer, 1);

    }

    //m_mainSplitter->addWidget(box);

    mainLayout->addWidget(box, 1);

  }

  setLayout(mainLayout);

  //m_mainSplitter->setSizes(QList<int>() << 270 << 500);</int>

  // signal-slot connections

  bool ret = connect(m_folderTreeView, SIGNAL(currentNodeChanged()),

                     itemViewPlayDelegate, SLOT(resetPlayWidget()));

  // if the current forder is changed in the folder tree, then update in the

  // item view

  ret = ret && connect(m_folderTreeView, SIGNAL(currentNodeChanged()), this,

                       SLOT(onTreeFolderChanged()));

  ret = ret && connect(m_itemViewer, SIGNAL(clickedItem(int)), this,

                       SLOT(onClickedItem(int)));

  ret = ret && connect(m_itemViewer, SIGNAL(doubleClickedItem(int)), this,

                       SLOT(onDoubleClickedItem(int)));

  ret =

      ret && connect(m_itemViewer, SIGNAL(selectedItems(const std::set<int> &)),</int>

                     this, SLOT(onSelectedItems(const std::set<int> &)));</int>

  ret = ret && connect(buttonBar, SIGNAL(newScene()), this, SLOT(newScene()));

  ret = ret && connect(&m_frameCountReader, SIGNAL(calculatedFrameCount()),

                       m_itemViewer->getPanel(), SLOT(update()));

  QAction *refresh = CommandManager::instance()->getAction(MI_RefreshTree);

  ret = ret && connect(refresh, SIGNAL(triggered()), this, SLOT(refresh()));

  addAction(refresh);

  // Version Control instance connection

  if (Preferences::instance()->isSVNEnabled())

    ret =

        ret && connect(VersionControl::instance(),

                       SIGNAL(commandDone(const QStringList &)), this,

                       SLOT(onVersionControlCommandDone(const QStringList &)));

  // if the folderName is edited, move the current folder accordingly

  ret = ret && connect(m_folderName, SIGNAL(editingFinished()), this,

                       SLOT(onFolderEdited()));

  // folder history

  ret = ret && connect(m_folderTreeView, SIGNAL(currentNodeChanged()), this,

                       SLOT(storeFolderHistory()));

  // check out the update of the current folder.

  // Use MyFileSystemWatcher which is shared by all browsers.

  // Adding and removing paths to the watcher is done in DvDirTreeView.

  ret = ret && connect(MyFileSystemWatcher::instance(),

                       SIGNAL(directoryChanged(const QString &)), this,

                       SLOT(onFileSystemChanged(const QString &)));

  // when the scene switched, update the path of the scene location node

  TSceneHandle *sceneHandle = TApp::instance()->getCurrentScene();

  //ret = ret && connect(sceneHandle, SIGNAL(sceneSwitched()), this,

  //                     SLOT(onSceneSwitched()));

  ret = ret && connect(sceneHandle, SIGNAL(nameSceneChanged()), this,

                       SLOT(onSceneSwitched()));

  //onSceneSwitched();

  // store the first item("Root") in the history

  m_indexHistoryList.append(m_folderTreeView->currentIndex());

  m_currentPosition = 0;

  refreshHistoryButtons();

  assert(ret);

}

//-----------------------------------------------------------------------------

SceneBrowser::~SceneBrowser() {}

//-----------------------------------------------------------------------------

/*! when the m_folderName is edited, move the current folder accordingly

 */

void SceneBrowser::onFolderEdited() {

  TFilePath inputPath(m_folderName->text().toStdWString());

  QModelIndex index = DvDirModel::instance()->getIndexByPath(inputPath);

  // If there is no node matched

  if (!index.isValid()) {

    QMessageBox::warning(this, tr("Open folder failed"),

                         tr("The input folder path was invalid."));

    return;

  }

  m_folderTreeView->collapseAll();

  m_folderTreeView->setCurrentIndex(index);

  // expand the folder tree

  QModelIndex tmpIndex = index;

  while (tmpIndex.isValid()) {

    m_folderTreeView->expand(tmpIndex);

    tmpIndex = tmpIndex.parent();

  }

  m_folderTreeView->scrollTo(index);

  m_folderTreeView->update();

}

//-----------------------------------------------------------------------------

void SceneBrowser::storeFolderHistory() {

  QModelIndex currentModelIndex = m_folderTreeView->currentIndex();

  if (!currentModelIndex.isValid()) return;

  if (m_indexHistoryList[m_currentPosition] == currentModelIndex) return;

  // If there is no next history item, then create it

  if (m_currentPosition == m_indexHistoryList.size() - 1) {

    m_indexHistoryList << currentModelIndex;

    m_currentPosition++;

  }

  // If the next hitory item is the same as the current one, just move to it

  else if (m_indexHistoryList[m_currentPosition + 1] == currentModelIndex) {

    m_currentPosition++;

  }

  // If the next history item is different from the current one, then replace

  // with the new one

  else {

    int size = m_indexHistoryList.size();

    // remove the old history items

    for (int i = m_currentPosition + 1; i < size; i++)

      m_indexHistoryList.removeLast();

    m_indexHistoryList << currentModelIndex;

    m_currentPosition++;

  }

  refreshHistoryButtons();

}

//-----------------------------------------------------------------------------

void SceneBrowser::refreshHistoryButtons() {

  emit historyChanged((m_currentPosition != 0),

                      (m_currentPosition != m_indexHistoryList.size() - 1));

}

//-----------------------------------------------------------------------------

void SceneBrowser::onBackButtonPushed() {

  if (m_currentPosition == 0) return;

  m_currentPosition--;

  QModelIndex currentIndex = m_indexHistoryList[m_currentPosition];

  m_folderTreeView->setCurrentIndex(currentIndex);

  m_folderTreeView->collapseAll();

  while (currentIndex.isValid()) {

    currentIndex = currentIndex.parent();

    m_folderTreeView->expand(currentIndex);

  }

  m_folderTreeView->update();

  refreshHistoryButtons();

}

//-----------------------------------------------------------------------------

void SceneBrowser::onFwdButtonPushed() {

  if (m_currentPosition >= m_indexHistoryList.size() - 1) return;

  m_currentPosition++;

  QModelIndex currentIndex = m_indexHistoryList[m_currentPosition];

  m_folderTreeView->setCurrentIndex(currentIndex);

  m_folderTreeView->collapseAll();

  while (currentIndex.isValid()) {

    currentIndex = currentIndex.parent();

    m_folderTreeView->expand(currentIndex);

  }

  m_folderTreeView->update();

  refreshHistoryButtons();

}

//-----------------------------------------------------------------------------

/*! clear the history when the tree date is replaced

 */

void SceneBrowser::clearHistory() {

  int size = m_indexHistoryList.size();

  // leave the last item

  for (int i = 1; i < size; i++) m_indexHistoryList.removeLast();

  m_currentPosition = 0;

  refreshHistoryButtons();

}

//-----------------------------------------------------------------------------

/*! update the current folder when changes detected from QFileSystemWatcher

 */

void SceneBrowser::onFileSystemChanged(const QString &folderPath) {

  if (folderPath != m_folder.getQString()) return;

  // changes may create/delete of folder, so update the DvDirModel

  QModelIndex parentFolderIndex = m_folderTreeView->currentIndex();

  DvDirModel::instance()->refresh(parentFolderIndex);

  refreshCurrentFolderItems();

}

//-----------------------------------------------------------------------------

void SceneBrowser::sortByDataModel(DataType dataType, bool isDiscendent) {

  struct locals {

    static inline bool itemLess(int aIdx, int bIdx, SceneBrowser &fb,

                                DataType dataType) {

      return (fb.compareData(dataType, aIdx, bIdx) > 0);

    }

    static inline bool indexLess(int aIdx, int bIdx,

                                 const std::vector<int> &vec) {</int>

      return (vec[aIdx] < vec[bIdx]);

    }

    static inline int complement(int val, int max) {

      return (assert(0 <= val && val <= max), max - val);

    }

  };  // locals

  if (dataType != getCurrentOrderType()) {

    // Build the permutation table

    std::vector<int> new2OldIdx(</int>

        boost::make_counting_iterator(0),

        boost::make_counting_iterator(int(m_items.size())));

    std::stable_sort(

        new2OldIdx.begin(), new2OldIdx.end(),

        boost::bind(locals::itemLess, _1, _2, boost::ref(*this), dataType));

    // Use the renumbering table to permutate elements

    std::vector<item>(</item>

        boost::make_permutation_iterator(m_items.begin(), new2OldIdx.begin()),

        boost::make_permutation_iterator(m_items.begin(), new2OldIdx.end()))

        .swap(m_items);

    // Use the permutation table to update current file selection, if any

    FileSelection *fs =

        static_cast<fileselection *="">(m_itemViewer->getPanel()->getSelection());</fileselection>

    if (!fs->isEmpty()) {

      std::vector<int> old2NewIdx(</int>

          boost::make_counting_iterator(0),

          boost::make_counting_iterator(int(m_items.size())));

      std::sort(old2NewIdx.begin(), old2NewIdx.end(),

                boost::bind(locals::indexLess, _1, _2, boost::ref(new2OldIdx)));

      std::vector<int> newSelectedIndices;</int>

      tcg::substitute(

          newSelectedIndices,

          tcg::permuted_range(old2NewIdx, fs->getSelectedIndices() |

                                              ba::filtered(boost::bind(

                                                  std::less<int>(), _1,</int>

                                                  int(old2NewIdx.size())))));

      fs->select(!newSelectedIndices.empty() ? &newSelectedIndices.front() : 0,

                 int(newSelectedIndices.size()));

    }

    setIsDiscendentOrder(true);

    setOrderType(dataType);

  }

  // Reverse lists if necessary

  if (isDiscendentOrder() != isDiscendent) {

    std::reverse(m_items.begin(), m_items.end());

    // Reverse file selection, if any

    FileSelection *fs =

        dynamic_cast<fileselection *="">(m_itemViewer->getPanel()->getSelection());</fileselection>

    if (!fs->isEmpty()) {

      int iCount = int(m_items.size()), lastIdx = iCount - 1;

      std::vector<int> newSelectedIndices;</int>

      tcg::substitute(

          newSelectedIndices,

          fs->getSelectedIndices() |

              ba::filtered(boost::bind(std::less<int>(), _1, iCount)) |</int>

              ba::transformed(boost::bind(locals::complement, _1, lastIdx)));

      fs->select(!newSelectedIndices.empty() ? &newSelectedIndices.front() : 0,

                 int(newSelectedIndices.size()));

    }

    setIsDiscendentOrder(isDiscendent);

  }

  m_itemViewer->getPanel()->update();

}

//-----------------------------------------------------------------------------

void SceneBrowser::setFilterTypes(const QStringList &types) { m_filter = types; }

//-----------------------------------------------------------------------------

void SceneBrowser::addFilterType(const QString &type) {

  if (!m_filter.contains(type)) m_filter.push_back(type);

}

//-----------------------------------------------------------------------------

void SceneBrowser::removeFilterType(const QString &type) {

  m_filter.removeAll(type);

}

//-----------------------------------------------------------------------------

void SceneBrowser::refreshCurrentFolderItems() {

  m_items.clear();

  // put the parent directory item

  //TFilePath parentFp = m_folder.getParentDir();

  //if (parentFp != TFilePath("") && parentFp != m_folder)

  //  m_items.push_back(Item(parentFp, true, false));

  // register the file items

  if (m_folder != TFilePath()) {

    TFilePathSet files;

    TFilePathSet all_files;  // for updating m_multiFileItemMap

    TFileStatus fpStatus(m_folder);

    // if the item is link, then set the link target of it

    if (fpStatus.isLink()) {

      QFileInfo info(toQString(m_folder));

      setFolder(TFilePath(info.symLinkTarget().toStdWString()));

      return;

    }

    if (fpStatus.doesExist() && fpStatus.isDirectory() &&

        fpStatus.isReadable()) {

      try {

        TSystem::readDirectory(files, all_files, m_folder);

      } catch (...) {

      }

    }

    TFilePathSet::iterator it;

    for (it = files.begin(); it != files.end(); ++it) {

      // skip the plt file (Palette file for TOONZ 4.6 and earlier)

      if (it->getType() == "plt") continue;

      // filter the file

      else if (m_filter.isEmpty()) {

        if (it->getType() != "tnz" && it->getType() != "scr" &&

            it->getType() != "tnzbat" && it->getType() != "mpath" &&

            it->getType() != "curve" && it->getType() != "tpl" &&

            TFileType::getInfo(*it) == TFileType::UNKNOW_FILE)

          continue;

      } else if (m_filter.contains(QString::fromStdString(it->getType())))

        continue;

      // store the filtered file paths

      m_items.push_back(Item(*it));

    }

    // update the m_multiFileItemMap

    m_multiFileItemMap.clear();

    for (it = all_files.begin(); it != all_files.end(); it++) {

      TFrameId tFrameId;

      tFrameId = it->getFrame();

      TFilePath levelName(it->getLevelName());

      if (levelName.isLevelName()) {

        Item &levelItem = m_multiFileItemMap[levelName];

        // TODO:

        // とりあえず残すが、FileInfoの取得に時間がかかるようならオプション化も検討

        // 2015/12/28 shun_iwasawa

        QFileInfo fileInfo(QString::fromStdWString(it->getWideString()));

        // Update level infos

        if (levelItem.m_creationDate.isNull() ||

            (fileInfo.created() < levelItem.m_creationDate))

          levelItem.m_creationDate = fileInfo.created();

        if (levelItem.m_modifiedDate.isNull() ||

            (fileInfo.lastModified() > levelItem.m_modifiedDate))

          levelItem.m_modifiedDate = fileInfo.lastModified();

        levelItem.m_fileSize += fileInfo.size();

        // store frameId

        levelItem.m_frameIds.push_back(tFrameId);

        levelItem.m_frameCount++;

      }

    }

  }

  // Set Missing Version Control Items

  int missingItemCount          = 0;

  DvDirVersionControlNode *node = dynamic_cast<dvdirversioncontrolnode *="">(</dvdirversioncontrolnode>

      m_folderTreeView->getCurrentNode());

  if (node) {

    QList<tfilepath> list = node->getMissingFiles();</tfilepath>

    missingItemCount      = list.size();

    for (int i = 0; i < missingItemCount; i++)

      m_items.push_back(Item(list.at(i)));

  }

  // Refresh Data (fill Item field)

  refreshData();

  // If I added some missing items I need to sort items.

  if (missingItemCount > 0) {

    DataType currentDataType = getCurrentOrderType();

    int i;

    for (i = 1; i < m_items.size(); i++) {

      int index = i;

      while (index > 0 && compareData(currentDataType, index - 1, index) > 0) {

        std::swap(m_items[index - 1], m_items[index]);

        index = index - 1;

      }

    }

  }

  // update the ordering rules

  bool discendentOrder     = isDiscendentOrder();

  DataType currentDataType = getCurrentOrderType();

  setOrderType(Name);

  setIsDiscendentOrder(true);

  sortByDataModel(currentDataType, discendentOrder);

}

//-----------------------------------------------------------------------------

void SceneBrowser::setFolder(const TFilePath &fp, bool expandNode,

                            bool forceUpdate) {

  if (fp == m_folder && !forceUpdate) return;

  // set the current folder path

  m_folder        = fp;

  m_dayDateString = "";

  // set the folder name

  if (fp == TFilePath())

    m_folderName->setText("");

  else

    m_folderName->setText(toQString(fp));

  refreshCurrentFolderItems();

  if (!TFileStatus(fp).isLink())

    m_folderTreeView->setCurrentNode(fp, expandNode);

}

//-----------------------------------------------------------------------------

/*! process when inputting the folder which is not regitered in the folder tree

   (e.g. UNC path in Windows)

 */

void SceneBrowser::setUnregisteredFolder(const TFilePath &fp) {

  if (fp != TFilePath()) {

    TFileStatus fpStatus(fp);

    // if the item is link, then set the link target of it

    if (fpStatus.isLink()) {

      QFileInfo info(toQString(fp));

      setFolder(TFilePath(info.symLinkTarget().toStdWString()));

      return;

    }

    // get both the folder & file list by readDirectory and

    // readDirectory_Dir_ReadExe

    TFilePathSet folders;

    TFilePathSet files;

    // for updating m_multiFileItemMap

    TFilePathSet all_files;

    if (fpStatus.doesExist() && fpStatus.isDirectory() &&

        fpStatus.isReadable()) {

      try {

        TSystem::readDirectory(files, all_files, fp);

        TSystem::readDirectory_Dir_ReadExe(folders, fp);

      } catch (...) {

      }

    }

    TFilePathSet::iterator it;

    // register all folder items

    for (it = folders.begin(); it != folders.end(); ++it) {

      if (TFileStatus(*it).isLink())

        m_items.push_back(Item(*it, true, true));

      else

        m_items.push_back(Item(*it, true, false));

    }

    for (it = files.begin(); it != files.end(); ++it) {

      // skip the plt file (Palette file for TOONZ 4.6 and earlier)

      if (it->getType() == "plt") continue;

      // filtering

      else if (m_filter.isEmpty()) {

        if (it->getType() != "tnz" && it->getType() != "scr" &&

            it->getType() != "tnzbat" && it->getType() != "mpath" &&

            it->getType() != "curve" && it->getType() != "tpl" &&

            TFileType::getInfo(*it) == TFileType::UNKNOW_FILE)

          continue;

      } else if (m_filter.contains(QString::fromStdString(it->getType())))

        continue;

      m_items.push_back(Item(*it));

    }

    // update the m_multiFileItemMap

    m_multiFileItemMap.clear();

    for (it = all_files.begin(); it != all_files.end(); it++) {

      TFilePath levelName(it->getLevelName());

      if (levelName.isLevelName()) {

        Item &levelItem = m_multiFileItemMap[levelName];

        levelItem.m_frameIds.push_back(it->getFrame());

        levelItem.m_frameCount++;

      }

    }

  }

  // for all items in the folder, retrieve the file names(m_name) from the

  // paths(m_path)

  refreshData();

  // update the ordering rules