#include "filebrowsermodel.h"

#include "tutil.h"

#include "tsystem.h"

#include "tconvert.h"

#include "tenv.h"

#include "toonz/tproject.h"

#include "toonz/toonzscene.h"

#include "toonzqt/gutil.h"

#include "filebrowser.h"

#include "history.h"

#include "iocommand.h"

#include <qfileinfo></qfileinfo>

#include <qdir></qdir>

#ifdef _WIN32

#include <shlobj.h></shlobj.h>

#include <winnetwk.h></winnetwk.h>

#endif

#ifdef MACOSX

#include <cocoa cocoa.h=""></cocoa>

#endif

#ifdef LINETEST

#include "tnzcamera.h"

#endif

namespace {

TFilePath getMyDocumentsPath() {

#ifdef _WIN32

  WCHAR szPath[MAX_PATH];

  if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_PERSONAL, 0)) {

    return TFilePath(szPath);

  }

  return TFilePath();

#elif defined MACOSX

  NSArray *foundref = NSSearchPathForDirectoriesInDomains(

      NSDocumentDirectory, NSUserDomainMask, YES);

  if (!foundref) return TFilePath();

  int c = [foundref count];

  assert(c == 1);

  NSString *documentsDirectory = [foundref objectAtIndex:0];

  return TFilePath((const char *)[documentsDirectory

      cStringUsingEncoding:NSASCIIStringEncoding]);

#else

  return TFilePath();

#endif

}

// Desktop Path

TFilePath getDesktopPath() {

#ifdef _WIN32

  WCHAR szPath[MAX_PATH];

  if (SHGetSpecialFolderPath(NULL, szPath, CSIDL_DESKTOP, 0)) {

    return TFilePath(szPath);

  }

  return TFilePath();

#elif defined MACOSX

  NSArray *foundref = NSSearchPathForDirectoriesInDomains(

      NSDesktopDirectory, NSUserDomainMask, YES);

  if (!foundref) return TFilePath();

  int c = [foundref count];

  assert(c == 1);

  NSString *desktopDirectory = [foundref objectAtIndex:0];

  return TFilePath((const char *)[desktopDirectory

      cStringUsingEncoding:NSASCIIStringEncoding]);

#else

  return TFilePath();

#endif

}

}

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

//

// DvDirModelNode

//

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

DvDirModelNode::DvDirModelNode(DvDirModelNode *parent, std::wstring name)

    : m_parent(parent)

    , m_name(name)

    , m_oldName()

    , m_row(-1)

    , m_childrenValid(false)

    , m_renameEnabled(false)

    , m_nodeType("") {}

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

DvDirModelNode::~DvDirModelNode() { clearPointerContainer(m_children); }

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

void DvDirModelNode::removeChildren(int row, int count) {

  assert(0 <= row && row + count <= (int)m_children.size());

  int i;

  for (i = 0; i < count; i++) delete m_children[row + i];

  m_children.erase(m_children.begin() + row, m_children.begin() + row + count);

  for (i = 0; i < (int)m_children.size(); i++) m_children[i]->setRow(i);

}

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

void DvDirModelNode::addChild(DvDirModelNode *child) {

  child->setRow(m_children.size());

  m_children.push_back(child);

}

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

int DvDirModelNode::getChildCount() {

  if (!m_childrenValid) refreshChildren();

  return (int)m_children.size();

}

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

DvDirModelNode *DvDirModelNode::getChild(int index) {

  if (!m_childrenValid) refreshChildren();

  assert(0 <= index && index < getChildCount());

  return m_children[index];

}

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

bool DvDirModelNode::hasChildren() {

  if (m_childrenValid)

    return getChildCount() > 0;

  else

    return true;

}

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

QPixmap DvDirModelNode::getPixmap(bool isOpen) const { return QPixmap(); }

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

void DvDirModelNode::setTemporaryName(const std::wstring &newName) {

  m_oldName = getName();

  m_name    = newName;

}

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

void DvDirModelNode::restoreName() {

  if (m_oldName != L"") {

    m_name    = m_oldName;

    m_oldName = L"";

  }

}

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

//

// DvDirModelFileFolderNode [File folder]

//

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

DvDirModelFileFolderNode::DvDirModelFileFolderNode(DvDirModelNode *parent,

                                                   std::wstring name,

                                                   const TFilePath &path)

    : DvDirModelNode(parent, name)

    , m_path(path)

    , m_isProjectFolder(false)

    , m_existsChecked(false)

    , m_exists(true)

    , m_hasChildren(false)

    , m_peeks(true) {

  m_nodeType = "FileFolder";

}

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

DvDirModelFileFolderNode::DvDirModelFileFolderNode(DvDirModelNode *parent,

                                                   const TFilePath &path)

    : DvDirModelNode(parent, path.withoutParentDir().getWideString())

    , m_path(path)

    , m_isProjectFolder(false)

    , m_existsChecked(false)

    , m_exists(true)

    , m_hasChildren(false)

    , m_peeks(true) {

  m_nodeType = "FileFolder";

}

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

bool DvDirModelFileFolderNode::exists() {

  return m_existsChecked ? m_exists : m_peeks

             ? m_existsChecked = true,

               m_exists        = TFileStatus(m_path).doesExist() : true;

}

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

void DvDirModelFileFolderNode::visualizeContent(FileBrowser *browser) {

  browser->setFolder(m_path);

}

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

DvDirModelNode *DvDirModelFileFolderNode::makeChild(std::wstring name) {

  return createNode(this, m_path + name);

}

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

DvDirModelFileFolderNode *DvDirModelFileFolderNode::createNode(

    DvDirModelNode *parent, const TFilePath &path) {

  DvDirModelFileFolderNode *node;

  // check the project nodes under the Poject Root Node

  if (QString::fromStdWString(parent->getName()).startsWith("Project root") &&

      TProjectManager::instance()->isProject(path))

    node = new DvDirModelProjectNode(parent, path);

  else {

    node = new DvDirModelFileFolderNode(parent, path);

    if (path.getName().find("_files") == std::string::npos)

      node->enableRename(true);

  }

  return node;

}

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

bool DvDirModelFileFolderNode::setName(std::wstring newName) {

  if (isSpaceString(QString::fromStdWString(newName))) return true;

  TFilePath srcPath = getPath();

  TFilePath dstPath = getPath().getParentDir() + newName;

  if (srcPath == dstPath) return false;

  try {

    TSystem::renameFile(dstPath, srcPath);

  } catch (...) {

    return false;

  }

  m_path = dstPath;

  m_name = newName;

  return true;

}

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

bool DvDirModelFileFolderNode::hasChildren() {

  if (m_childrenValid) return m_hasChildren;

  if (m_peeks) {

    // Using QDir directly rather than

    // DvDirModelFileFolderNode::refreshChildren() due to

    // performance issues

    QDir dir(QString::fromStdWString(m_path.getWideString()));

    dir.setFilter(QDir::AllDirs | QDir::NoDotAndDotDot);

    return (dir.count() > 0);

  } else

    return true;  // Not peeking nodes allow users to actively scan for

                  // sub-folders

}

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

void DvDirModelFileFolderNode::refreshChildren() {

  m_childrenValid = true;

  std::vector<std::wstring> names;</std::wstring>

  getChildrenNames(names);

  std::vector<dvdirmodelnode *=""> oldChildren;</dvdirmodelnode>

  oldChildren.swap(m_children);

  std::vector<dvdirmodelnode *="">::iterator j;</dvdirmodelnode>

  int i;

  for (i = 0; i < (int)names.size(); i++) {

    std::wstring name = names[i];

    for (j = oldChildren.begin();

         j != oldChildren.end() && (*j)->getName() != name; ++j) {

    }

    DvDirModelNode *child = 0;

    if (j != oldChildren.end()) {

      child = *j;

      oldChildren.erase(j);

    } else {

      child = makeChild(name);

      if (DvDirModelFileFolderNode *folderNode =

              dynamic_cast<dvdirmodelfilefoldernode *="">(child))</dvdirmodelfilefoldernode>

        folderNode->setPeeking(m_peeks);

    }

    if (!child) continue;

    addChild(child);

  }

  for (j = oldChildren.begin(); j != oldChildren.end(); ++j) {

    DvDirModelNode *child = *j;

    if (!!child && child->hasChildren())

      child->removeChildren(0, child->getChildCount());

    delete *j;

  }

  m_hasChildren = (m_children.size() > 0);

}

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

void DvDirModelFileFolderNode::getChildrenNames(

    std::vector<std::wstring> &names) const {</std::wstring>

  TFileStatus folderPathStatus(m_path);

  if (folderPathStatus.isLink()) return;

  QStringList entries;

  if (folderPathStatus.isDirectory()) {

    QDir dir(toQString(m_path));

    entries = dir.entryList(QDir::AllDirs | QDir::NoDotAndDotDot,

                            QDir::Name | QDir::LocaleAware);

  }

  int e, eCount = entries.size();

  for (e = 0; e != eCount; ++e) names.push_back(entries[e].toStdWString());

}

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

int DvDirModelFileFolderNode::rowByName(const std::wstring &name) const {

  std::vector<std::wstring> names;</std::wstring>

  getChildrenNames(names);

  std::vector<std::wstring>::iterator it =</std::wstring>

      std::find(names.begin(), names.end(), name);

  if (it == names.end())

    return -1;

  else

    return std::distance(names.begin(), it);

}

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

DvDirModelNode *DvDirModelFileFolderNode::getNodeByPath(const TFilePath &path) {

  if (path == m_path) return this;

  if (!m_path.isAncestorOf(path)) return 0;

  int i, n = getChildCount();

  for (i = 0; i < n; i++) {

    DvDirModelNode *node = getChild(i)->getNodeByPath(path);

    if (node) return node;

  }

  return 0;

}

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

QPixmap DvDirModelFileFolderNode::getPixmap(bool isOpen) const {

  static QPixmap openFolderPixmap(":Resources/browser_folder_open.png");

  static QPixmap closeFolderPixmap(":Resources/browser_folder_close.png");

  return isOpen ? openFolderPixmap : closeFolderPixmap;

}

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

//

// DvDirModelSceneFolderNode

//

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

DvDirModelSceneFolderNode::DvDirModelSceneFolderNode(DvDirModelNode *parent,

                                                     std::wstring name,

                                                     const TFilePath &scenePath)

    : DvDirModelFileFolderNode(parent, name, scenePath) {}

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

DvDirModelSceneFolderNode::DvDirModelSceneFolderNode(DvDirModelNode *parent,

                                                     const TFilePath &path)

    : DvDirModelFileFolderNode(parent, path.withoutParentDir().getWideString(),

                               path) {

  try {

    ToonzScene scene;

    scene.setScenePath(path);

    TProjectP project = TProjectManager::instance()->loadSceneProject(path);

    if (!project) return;

    scene.setProject(project.getPointer());

    for (int i = 0; i < project->getFolderCount(); i++) {

      std::string folderName = project->getFolderName(i);

      TFilePath folderPath   = project->getFolder(i);

      if (folderPath.isAbsolute() && !project->isConstantFolder(i)) {

        std::wstring alias         = L"+" + ::to_wstring(folderName);

        TFilePath folderActualPath = scene.decodeFilePath(TFilePath(alias));

        m_folders[alias]           = folderActualPath;

      }

    }

  } catch (...) {

  }

}

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

DvDirModelSceneFolderNode::~DvDirModelSceneFolderNode() {}

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

bool DvDirModelSceneFolderNode::setName(std::wstring newName) {

  m_name = newName;

  return true;

}

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

QPixmap DvDirModelSceneFolderNode::getPixmap(bool isOpen) const {

  static QPixmap openFolderPixmap(":Resources/browser_scene_open.png");

  static QPixmap closeFolderPixmap(":Resources/browser_scene_close.png");

  return isOpen ? openFolderPixmap : closeFolderPixmap;

}

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

DvDirModelNode *DvDirModelSceneFolderNode::makeChild(std::wstring name) {

  TFilePath actualFolderPath = m_folders[name];

  DvDirModelFileFolderNode *node =

      new DvDirModelFileFolderNode(this, name, actualFolderPath);

  node->enableRename(false);

  return node;

}

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

void DvDirModelSceneFolderNode::getChildrenNames(

    std::vector<std::wstring> &names) const {</std::wstring>

  std::map<std::wstring, tfilepath="">::const_iterator it;</std::wstring,>

  for (it = m_folders.begin(); it != m_folders.end(); ++it)

    names.push_back(it->first);

}

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

void DvDirModelSceneFolderNode::refreshChildren() {

  m_childrenValid = true;

  std::vector<std::wstring> names;</std::wstring>

  getChildrenNames(names);

  std::vector<dvdirmodelnode *=""> oldChildren;</dvdirmodelnode>

  oldChildren.swap(m_children);

  std::vector<dvdirmodelnode *="">::iterator j;</dvdirmodelnode>

  int i;

  for (i = 0; i < (int)names.size(); i++) {

    std::wstring name = names[i];

    for (j = oldChildren.begin();

         j != oldChildren.end() && (*j)->getName() != name; ++j) {

    }

    DvDirModelNode *child = 0;

    if (j != oldChildren.end()) {

      child = *j;

      oldChildren.erase(j);

    } else {

      child = makeChild(name);

    }

    addChild(child);

  }

  for (j = oldChildren.begin(); j != oldChildren.end(); ++j) {

    DvDirModelNode *child = *j;

    if (!!child && child->hasChildren())

      child->removeChildren(0, child->getChildCount());

    delete *j;

  }

}

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

DvDirModelFileFolderNode *DvDirModelSceneFolderNode::createNode(

    DvDirModelNode *parent, const TFilePath &path) {

  DvDirModelFileFolderNode *node = new DvDirModelFileFolderNode(parent, path);

  if (path.getName().find("_files") == std::string::npos)

    node->enableRename(true);

  return node;

}

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

int DvDirModelSceneFolderNode::rowByName(const std::wstring &name) {

  std::vector<std::wstring> names;</std::wstring>

  getChildrenNames(names);

  std::vector<std::wstring>::iterator it =</std::wstring>

      std::find(names.begin(), names.end(), name);

  if (it == names.end())

    return -1;

  else

    return std::distance(names.begin(), it);

}

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

//

// DvDirModelSpecialFileFolderNode [Special File Folder]

//

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

DvDirModelSpecialFileFolderNode::DvDirModelSpecialFileFolderNode(

    DvDirModelNode *parent, std::wstring name, const TFilePath &path)

    : DvDirModelFileFolderNode(parent, name, path) {}

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

QPixmap DvDirModelSpecialFileFolderNode::getPixmap(bool isOpen) const {

  return m_pixmap;

}

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

void DvDirModelSpecialFileFolderNode::setPixmap(const QPixmap &pixmap) {

  m_pixmap = pixmap;

}

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

//

// DvDirVersionControlNode [Special File Folder]

//

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

DvDirVersionControlNode::DvDirVersionControlNode(DvDirModelNode *parent,

                                                 std::wstring name,

                                                 const TFilePath &path)

    : DvDirModelFileFolderNode(parent, name, path)

    , m_isSynched(false)

    , m_isUnversioned(false)

    , m_oldName() {

  this->setExists(TFileStatus(path).doesExist());

  setIsUnderVersionControl(

      VersionControl::instance()->isFolderUnderVersionControl(toQString(path)));

}

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

QList<tfilepath> DvDirVersionControlNode::getMissingFiles() const {</tfilepath>

  QList<tfilepath> list;</tfilepath>

  QMap<qstring, svnstatus="">::const_iterator i = m_statusMap.constBegin();</qstring,>

  while (i != m_statusMap.constEnd()) {

    SVNStatus s = i.value();

    if (s.m_item == "missing" ||

        s.m_item == "none" && s.m_repoStatus == "added") {

      TFilePath path(getPath() + TFilePath(s.m_path.toStdWString()));

      std::string dots = path.getDots();

      if (dots != "") {

        if (dots == "..") path = path.getParentDir() + path.getLevelNameW();

        if (!list.contains(path)) list.append(path);

      }

    }

    i++;

  }

  return list;

}

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

QStringList DvDirVersionControlNode::getMissingFiles(

    const QRegExp &filter) const {

  QStringList list;

  QMap<qstring, svnstatus="">::const_iterator i = m_statusMap.constBegin();</qstring,>

  for (; i != m_statusMap.constEnd(); i++) {

    SVNStatus s = i.value();

    if (s.m_item == "missing" ||

        s.m_item == "none" && s.m_repoStatus == "added") {

      TFilePath path(s.m_path.toStdWString());

      if (!filter.exactMatch(

              QString::fromStdWString(path.withoutParentDir().getWideString())))

        continue;

      std::string dots = path.getDots();

      if (dots != "") list.append(toQString(path));

    }

  }

  return list;

}

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

QList<tfilepath> DvDirVersionControlNode::getMissingFolders() const {</tfilepath>

  QList<tfilepath> list;</tfilepath>

  QMap<qstring, svnstatus="">::const_iterator i = m_statusMap.constBegin();</qstring,>

  while (i != m_statusMap.constEnd()) {

    SVNStatus s = i.value();

    if (s.m_item == "missing" ||

        (s.m_item == "none" && s.m_repoStatus == "added")) {

      TFilePath path(getPath() + TFilePath(s.m_path.toStdWString()));

      if (path.getDots() == "" || path.getType() == "tnz") {

        QString currentFolderName =

            QString::fromStdWString(getPath().getWideName());

        if (currentFolderName != s.m_path) {

          if (!s.m_path.contains("\\"))

            list.append(path);

          else {

            QString newPath = s.m_path.replace(currentFolderName + "\\", "");

            if (!newPath.contains("\\"))

              list.append(getPath() + TFilePath(newPath.toStdWString()));

          }

        }

      }

    }

    i++;

  }

  return list;

}

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

void DvDirVersionControlNode::getChildrenNames(

    std::vector<std::wstring> &names) const {</std::wstring>

  DvDirModelFileFolderNode::getChildrenNames(names);

  QList<tfilepath> missingFolders = getMissingFolders();</tfilepath>

  int count                       = missingFolders.size();

  for (int i = 0; i < count; i++) {

    std::wstring name = missingFolders.at(i).getWideName();

    if (find(names.begin(), names.end(), name) == names.end())

      names.push_back(name);

  }

}

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

void DvDirVersionControlNode::setIsUnderVersionControl(bool value) {

  // Set the flags and enable/disable renaming accordling

  m_isUnderVersionControl = value;

  enableRename(!value);

}

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

DvDirModelNode *DvDirVersionControlNode::makeChild(std::wstring name) {

  if (TProjectManager::instance()->isProject(getPath() + name))

    return new DvDirVersionControlProjectNode(this, name, getPath() + name);

  return new DvDirVersionControlNode(this, name, getPath() + name);

}

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

QPixmap DvDirVersionControlNode::getPixmap(bool isOpen) const {

  static QPixmap openFolderPixmap(":Resources/browser_folder_open.png");

  static QPixmap closeFolderPixmap(":Resources/browser_folder_close.png");

  static QPixmap openMissingPixmap(":Resources/vcfolder_mis_open.png");

  static QPixmap closeMissingPixmap(":Resources/vcfolder_mis_close.png");

  static QPixmap openSceneFolderPixmap(":Resources/browser_scene_open.png");

  static QPixmap closeSceneFolderPixmap(":Resources/browser_scene_close.png");

  if (TFileStatus(getPath()).doesExist()) {

    if (getPath().getType() == "tnz")

      return isOpen ? openSceneFolderPixmap : closeSceneFolderPixmap;

    else

      return isOpen ? openFolderPixmap : closeFolderPixmap;

  } else

    return isOpen ? openMissingPixmap : closeMissingPixmap;

}

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

void DvDirVersionControlNode::insertVersionControlStatus(

    const QString &fileName, SVNStatus status) {

  m_statusMap.insert(fileName, status);

}

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

SVNStatus DvDirVersionControlNode::getVersionControlStatus(

    const QString &fileName) {

  if (m_statusMap.contains(fileName)) return m_statusMap.value(fileName);

  SVNStatus s         = SVNStatus();

  s.m_isLocked        = false;

  s.m_isPartialEdited = false;

  s.m_isPartialLocked = false;

  return s;

}

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

QStringList DvDirVersionControlNode::refreshVersionControl(

    const QList<svnstatus> &status) {</svnstatus>

  TFilePath nodePath = getPath();

  if (nodePath.isEmpty()) return QStringList();

  int listSize   = status.size();

  bool isSynched = true;

  QStringList checkPartialLockList;

  for (int i = 0; i < listSize; i++) {

    SVNStatus s = status.at(i);

    // It is not needed to check and cache SVNStatus for files that are

    // "outside" the node "scope"

    if (s.m_path == "." || s.m_path == ".." || s.m_path.split("\\").size() > 2)

      continue;

    QString fileName = s.m_path;

    if (nodePath.getType() == "") insertVersionControlStatus(fileName, s);

    // Update also the status of the "scene" child folders

    TFilePath path(fileName.toStdWString());

    if (path.getType() == "tnz") {

      DvDirVersionControlNode *childVcNode =

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

              getNodeByPath(nodePath + path));

      if (childVcNode) {

        childVcNode->setIsUnderVersionControl(true);

        if (s.m_repoStatus == "modified" || s.m_item == "modified" ||

            s.m_item == "missing" || s.m_item == "none")

          childVcNode->setIsSynched(false);

        else if (s.m_item == "unversioned")

          childVcNode->setIsUnversioned(true);

        else

          childVcNode->setIsSynched(true);

      }

    }

    // If a folder is unversioned, I set its status and even the unversioned

    // status for its children

    else if (path.getType() == "" && s.m_item == "unversioned") {

      DvDirVersionControlNode *childVcNode =

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

              getNodeByPath(nodePath + path));

      if (childVcNode) {

        childVcNode->setIsUnversioned(true);

        int childCount = childVcNode->getChildCount();

        for (int i = 0; i < childCount; i++) {

          DvDirVersionControlNode *subChildNode =

              dynamic_cast<dvdirversioncontrolnode *="">(childVcNode->getChild(i));</dvdirversioncontrolnode>

          if (subChildNode) subChildNode->setIsUnversioned(true);

        }

      }

    }

    // Check also the 'partial-lock' property

    std::string type = TFilePath(s.m_path.toStdWString()).getType();

    if (type == "tlv" || type == "pli") {

      if (s.m_item != "unversioned" && s.m_item != "missing" &&

          s.m_repoStatus != "added")

        checkPartialLockList.append(s.m_path);

    }

    if (s.m_repoStatus == "modified" || s.m_item == "modified" ||

        s.m_item == "unversioned" || s.m_item == "missing" ||

        s.m_item == "none")

      isSynched = false;

  }

  setIsSynched(isSynched);

  return checkPartialLockList;

}

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

DvDirVersionControlRootNode *

DvDirVersionControlNode::getVersionControlRootNode() {

  DvDirModelNode *parent = getParent();

  if (parent) return parent->getVersionControlRootNode();

  return 0;

}

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

//

// DvDirVersionControlRootNode [Special File Folder]

//

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

DvDirVersionControlRootNode::DvDirVersionControlRootNode(DvDirModelNode *parent,

                                                         std::wstring name,

                                                         const TFilePath &path)

    : DvDirVersionControlNode(parent, name, path) {

  setPixmap(QPixmap(":Resources/vcroot.png"));

  setIsUnderVersionControl(true);

}

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

void DvDirVersionControlRootNode::refreshChildren() {

  DvDirModelFileFolderNode::refreshChildren();

}

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

// DvDirVersionControlProjectNode

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

DvDirVersionControlProjectNode::DvDirVersionControlProjectNode(

    DvDirModelNode *parent, std::wstring name, const TFilePath &path)

    : DvDirVersionControlNode(parent, name, path) {

  m_nodeType = "Project";

  setIsUnderVersionControl(true);

}

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

TFilePath DvDirVersionControlProjectNode::getProjectPath() const {

  return TProjectManager::instance()->projectFolderToProjectPath(getPath());

}

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

bool DvDirVersionControlProjectNode::isCurrent() const {

  TProjectManager *pm = TProjectManager::instance();

  return pm->getCurrentProjectPath().getParentDir() == getPath();

}

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

void DvDirVersionControlProjectNode::makeCurrent() {

  TProjectManager *pm   = TProjectManager::instance();

  TFilePath projectPath = getProjectPath();

  if (!IoCmd::saveSceneIfNeeded(QObject::tr("Change project"))) return;

  pm->setCurrentProjectPath(projectPath);

  IoCmd::newScene();

}

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

QPixmap DvDirVersionControlProjectNode::getPixmap(bool isOpen) const {

  static QPixmap openPixmap(":Resources/browser_vcproject_open.png");

  static QPixmap closePixmap(":Resources/browser_vcproject_close.png");

  static QPixmap openMissingPixmap(":Resources/vcfolder_mis_open.png");

  static QPixmap closeMissingPixmap(":Resources/vcfolder_mis_close.png");

  if (TFileStatus(getPath()).doesExist())

    return isOpen ? openPixmap : closePixmap;

  else

    return isOpen ? openMissingPixmap : closeMissingPixmap;

}

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

void DvDirVersionControlProjectNode::refreshChildren() {

  DvDirModelFileFolderNode::refreshChildren();

  int i;

  TProjectManager *pm = TProjectManager::instance();

  TProject *project   = new TProject();

  project->load(getProjectPath());

  for (i = 0; i < getChildCount(); i++) {

    DvDirModelFileFolderNode *node =

        dynamic_cast<dvdirmodelfilefoldernode *="">(getChild(i));</dvdirmodelfilefoldernode>

    if (node) {

      int k = project->getFolderIndexFromPath(node->getPath());

      node->setIsProjectFolder(k >= 0);

    }

  }

  delete project;

}

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

void DvDirVersionControlProjectNode::getChildrenNames(

    std::vector<std::wstring> &names) const {</std::wstring>

  DvDirVersionControlNode::getChildrenNames(names);

  TProjectManager *pm = TProjectManager::instance();

  TProject *project   = new TProject();

  project->load(getProjectPath());

  int i;

  for (i = 0; i < project->getFolderCount(); i++) {

    std::string folderName = project->getFolderName(i);

    TFilePath folderPath   = project->getFolder(i);

    // if(folderPath.isAbsolute() || folderPath.getParentDir() != TFilePath())

    if (folderPath.isAbsolute() && project->isConstantFolder(i)) {

      names.push_back(L"+" + ::to_wstring(folderName));

    }

  }

  delete project;

}

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

//

// DvDirModelProjectNode [Project Folder]

//

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

DvDirModelProjectNode::DvDirModelProjectNode(DvDirModelNode *parent,

                                             const TFilePath &path)

    : DvDirModelFileFolderNode(parent, path) {

  m_nodeType = "Project";

}

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

TFilePath DvDirModelProjectNode::getProjectPath() const {

  return TProjectManager::instance()->projectFolderToProjectPath(getPath());