void JsonSummaryPage::addToProject(const JsonWizard::GeneratorFiles &files)
{
QTC_CHECK(m_fileList.isEmpty()); // Happens after this page is done
QString generatedProject = generatedProjectFilePath(files);
IWizardFactory::WizardKind kind = wizardKind(m_wizard);
FolderNode *folder = currentNode();
if (!folder)
return;
if (kind == IWizardFactory::ProjectWizard) {
if (!static_cast<ProjectNode *>(folder)->addSubProjects(QStringList(generatedProject))) {
QMessageBox::critical(m_wizard, tr("Failed to Add to Project"),
tr("Failed to add subproject \"%1\"\nto project \"%2\".")
.arg(QDir::toNativeSeparators(generatedProject))
.arg(folder->filePath().toUserOutput()));
return;
}
m_wizard->removeAttributeFromAllFiles(GeneratedFile::OpenProjectAttribute);
} else {
QStringList filePaths = Utils::transform(files, [](const JsonWizard::GeneratorFile &f) {
return f.file.path();
});
if (!folder->addFiles(filePaths)) {
QStringList nativeFilePaths = Utils::transform(filePaths, &QDir::toNativeSeparators);
QMessageBox::critical(wizard(), tr("Failed to Add to Project"),
tr("Failed to add one or more files to project\n\"%1\" (%2).")
.arg(folder->filePath().toUserOutput(),
nativeFilePaths.join(QLatin1String(", "))));
return;
}
}
return;
}
FolderNode *GenericProjectNode::createFolderByName(const QStringList &components, int end)
{
if (end == 0)
return this;
QString folderName;
for (int i = 0; i < end; ++i) {
folderName.append(components.at(i));
folderName += QLatin1Char('/');
}
const QString component = components.at(end - 1);
if (component.isEmpty())
return this;
const QString baseDir = QFileInfo(path()).path();
FolderNode *folder = new FolderNode(baseDir + QLatin1Char('/') + folderName);
folder->setDisplayName(component);
FolderNode *parent = findFolderByName(components, end - 1);
if (!parent)
parent = createFolderByName(components, end - 1);
addFolderNodes(QList<FolderNode*>() << folder, parent);
return folder;
}
// Add files to project && version control
bool ProjectFileWizardExtension::processProject(
const QList<GeneratedFile> &files,
bool *removeOpenProjectAttribute, QString *errorMessage)
{
*removeOpenProjectAttribute = false;
QString generatedProject = generatedProjectFilePath(files);
FolderNode *folder = m_context->page->currentNode();
if (!folder)
return true;
if (m_context->wizard->kind() == IWizardFactory::ProjectWizard) {
if (!static_cast<ProjectNode *>(folder)->addSubProjects(QStringList(generatedProject))) {
*errorMessage = tr("Failed to add subproject \"%1\"\nto project \"%2\".")
.arg(generatedProject).arg(folder->path());
return false;
}
*removeOpenProjectAttribute = true;
} else {
QStringList filePaths = Utils::transform(files, &GeneratedFile::path);
if (!folder->addFiles(filePaths)) {
*errorMessage = tr("Failed to add one or more files to project\n\"%1\" (%2).").
arg(folder->path(), filePaths.join(QLatin1Char(',')));
return false;
}
}
return true;
}
QModelIndex FlatModel::parent(const QModelIndex &idx) const
{
QModelIndex parentIndex;
if (Node *node = nodeForIndex(idx)) {
FolderNode *parentNode = visibleFolderNode(node->parentFolderNode());
if (parentNode) {
FolderNode *grandParentNode = visibleFolderNode(parentNode->parentFolderNode());
if (grandParentNode) {
QHash<FolderNode*, QList<Node*> >::const_iterator it = m_childNodes.constFind(grandParentNode);
if (it == m_childNodes.constEnd()) {
fetchMore(grandParentNode);
it = m_childNodes.constFind(grandParentNode);
}
Q_ASSERT(it != m_childNodes.constEnd());
const int row = it.value().indexOf(parentNode);
Q_ASSERT(row >= 0);
parentIndex = createIndex(row, 0, parentNode);
} else {
// top level node, parent is session
parentIndex = index(0, 0, QModelIndex());
}
}
}
// qDebug() << "parent of " << idx.data(Project::FilePathRole) << " is " << parentIndex.data(Project::FilePathRole);
return parentIndex;
}
QVariant FlatModel::data(const QModelIndex &index, int role) const
{
QVariant result;
if (Node *node = nodeForIndex(index)) {
FolderNode *folderNode = node->asFolderNode();
switch (role) {
case Qt::DisplayRole: {
QString name = node->displayName();
if (node->nodeType() == NodeType::Project
&& node->parentFolderNode()
&& node->parentFolderNode()->nodeType() == NodeType::Session) {
const QString vcsTopic = static_cast<ProjectNode *>(node)->vcsTopic();
if (!vcsTopic.isEmpty())
name += QLatin1String(" [") + vcsTopic + QLatin1Char(']');
}
result = name;
break;
}
case Qt::EditRole: {
result = node->filePath().fileName();
break;
}
case Qt::ToolTipRole: {
result = node->tooltip();
break;
}
case Qt::DecorationRole: {
if (folderNode)
result = folderNode->icon();
else
result = Core::FileIconProvider::icon(node->filePath().toString());
break;
}
case Qt::FontRole: {
QFont font;
if (node == m_startupProject)
font.setBold(true);
result = font;
break;
}
case Project::FilePathRole: {
result = node->filePath().toString();
break;
}
case Project::EnabledRole: {
result = node->isEnabled();
break;
}
}
}
return result;
}
void NimProject::addNodes(const QSet<QString> &nodes)
{
QStringList path;
foreach (const QString &node, nodes) {
path = m_projectDir.relativeFilePath(node).split(QDir::separator());
path.pop_back();
FolderNode *folder = findFolderFor(path);
auto fileNode = new FileNode(FileName::fromString(node), SourceType, false);
folder->addFileNodes({fileNode});
}
void ResourceEditorPlugin::removeFileContextMenu()
{
ResourceFolderNode *rfn = static_cast<ResourceFolderNode *>(ProjectTree::currentNode());
QString path = rfn->path().toString();
FolderNode *parent = rfn->parentFolderNode();
if (!parent->removeFiles(QStringList() << path))
QMessageBox::warning(Core::ICore::mainWindow(),
tr("File Removal Failed"),
tr("Removing file %1 from the project failed.").arg(path));
}
QVariant FlatModel::data(const QModelIndex &index, int role) const
{
QVariant result;
if (Node *node = nodeForIndex(index)) {
FolderNode *folderNode = qobject_cast<FolderNode*>(node);
switch (role) {
case Qt::DisplayRole: {
QString name = node->displayName();
if (node->parentFolderNode()
&& node->parentFolderNode()->nodeType() == SessionNodeType) {
const QString vcsTopic = node->vcsTopic();
if (!vcsTopic.isEmpty())
name += " (" + vcsTopic + ")";
}
result = name;
break;
}
case Qt::EditRole: {
result = node->displayName();
break;
}
case Qt::ToolTipRole: {
result = node->tooltip();
break;
}
case Qt::DecorationRole: {
if (folderNode)
result = folderNode->icon();
else
result = FileIconProvider::instance()->icon(QFileInfo(node->path()));
break;
}
case Qt::FontRole: {
QFont font;
if (node == m_startupProject)
font.setBold(true);
result = font;
break;
}
case ProjectExplorer::Project::FilePathRole: {
result = node->path();
break;
}
}
}
return result;
}
void ResourceEditorPlugin::updateContextActions(Node *node, Project *)
{
bool isResourceNode = dynamic_cast<ResourceTopLevelNode *>(node);
m_addPrefix->setEnabled(isResourceNode);
m_addPrefix->setVisible(isResourceNode);
bool enableRename = false;
bool enableRemove = false;
if (isResourceNode) {
FolderNode *parent = node ? node->parentFolderNode() : 0;
enableRename = parent && parent->supportedActions(node).contains(Rename);
enableRemove = parent && parent->supportedActions(node).contains(RemoveFile);
}
m_renameResourceFile->setEnabled(isResourceNode && enableRename);
m_renameResourceFile->setVisible(isResourceNode && enableRename);
m_removeResourceFile->setEnabled(isResourceNode && enableRemove);
m_removeResourceFile->setVisible(isResourceNode && enableRemove);
m_openInEditor->setEnabled(isResourceNode);
m_openInEditor->setVisible(isResourceNode);
bool isResourceFolder = dynamic_cast<ResourceFolderNode *>(node);
m_removePrefix->setEnabled(isResourceFolder);
m_removePrefix->setVisible(isResourceFolder);
m_renamePrefix->setEnabled(isResourceFolder);
m_renamePrefix->setVisible(isResourceFolder);
m_removeNonExisting->setEnabled(isResourceNode);
m_removeNonExisting->setVisible(isResourceNode);
if (isResourceNode)
Core::EditorManager::populateOpenWithMenu(m_openWithMenu, node->path().toString());
else
m_openWithMenu->clear();
m_openWithMenu->menuAction()->setVisible(!m_openWithMenu->actions().isEmpty());
bool isResourceFile = dynamic_cast<ResourceFileNode *>(node);
m_copyPath->setEnabled(isResourceFile);
m_copyPath->setVisible(isResourceFile);
m_copyUrl->setEnabled(isResourceFile);
m_copyUrl->setVisible(isResourceFile);
if (isResourceFile) {
ResourceFileNode *fileNode = static_cast<ResourceFileNode *>(node);
QString qrcPath = fileNode->qrcPath();
m_copyPath->setParameter(QLatin1String(resourcePrefix) + qrcPath);
m_copyUrl->setParameter(QLatin1String(urlPrefix) + qrcPath);
}
}
Project *ProjectTree::projectForNode(Node *node)
{
if (!node)
return 0;
FolderNode *rootProjectNode = node->asFolderNode();
if (!rootProjectNode)
rootProjectNode = node->parentFolderNode();
while (rootProjectNode && rootProjectNode->parentFolderNode() != SessionManager::sessionNode())
rootProjectNode = rootProjectNode->parentFolderNode();
Q_ASSERT(rootProjectNode);
return Utils::findOrDefault(SessionManager::projects(), Utils::equal(&Project::rootProjectNode, rootProjectNode));
}
static void addCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, int priority,
const QString &displayName,
std::vector<std::unique_ptr<FileNode>> &&files)
{
if (files.size() == 0)
return;
FolderNode *folder = base;
if (!displayName.isEmpty()) {
auto newFolder = std::make_unique<VirtualFolderNode>(basePath, priority);
newFolder->setDisplayName(displayName);
folder = newFolder.get();
base->addNode(std::move(newFolder));
}
folder->addNestedNodes(std::move(files));
for (FolderNode *fn : folder->folderNodes())
fn->compress();
}
FormContainer* COutlookFrame::GetFormContainer()
{
COutlookFrame* pFrame = static_cast<COutlookFrame*>(AfxGetMainWnd());
VERIFY(pFrame);
FolderNode* pFolderNode = static_cast<FolderNode*>(pFrame->m_pInterface->GetOutlookPane()->GetNode(0));
InterfaceNode* pInterfaceNode = pFolderNode->GetSelNode();
FolderNode* pFolderNode2 = dynamic_cast<FolderNode*>(pInterfaceNode);
while (pFolderNode2 != NULL) {
pInterfaceNode = pFolderNode2->GetSelNode();
pFolderNode2 = dynamic_cast<FolderNode*>(pInterfaceNode);
}
if (dynamic_cast<MViewNode*>(pInterfaceNode) == NULL) {
return NULL;
}
MViewNode* pNode = static_cast<MViewNode*>(pInterfaceNode);
return static_cast<FormContainer*>(pNode->GetFormContainer());
}
FolderNode *setupCMakeVFolder(FolderNode *base, const Utils::FileName &basePath, int priority,
const QString &displayName, QList<FileNode *> &files)
{
if (files.isEmpty())
return nullptr;
FolderNode *folder
= findOrDefault(base->folderNodes(), [basePath](const FolderNode *fn) {
return fn->filePath() == basePath;
});
if (!folder) {
folder = new VirtualFolderNode(basePath, priority);
folder->setDisplayName(displayName);
base->addFolderNodes({ folder });
}
folder->buildTree(files);
return folder;
}
QVariant FlatModel::data(const QModelIndex &index, int role) const
{
QVariant result;
if (Node *node = nodeForIndex(index)) {
FolderNode *folderNode = qobject_cast<FolderNode*>(node);
switch (role) {
case Qt::DisplayRole:
case Qt::EditRole: {
if (folderNode)
result = folderNode->displayName();
else
result = QFileInfo(node->path()).fileName(); //TODO cache that?
break;
}
case Qt::ToolTipRole: {
result = QDir::toNativeSeparators(node->path());
break;
}
case Qt::DecorationRole: {
if (folderNode)
result = folderNode->icon();
else
result = FileIconProvider::instance()->icon(QFileInfo(node->path()));
break;
}
case Qt::FontRole: {
QFont font;
if (node == m_startupProject)
font.setBold(true);
result = font;
break;
}
case ProjectExplorer::Project::FilePathRole: {
result = node->path();
break;
}
}
}
return result;
}
FolderNode *GenericProjectNode::findFolderByName(const QStringList &components, int end)
{
if (end == 0)
return this;
QString folderName;
for (int i = 0; i < end; ++i) {
folderName.append(components.at(i));
folderName += QLatin1Char('/');
}
FolderNode *parent = findFolderByName(components, end - 1);
if (!parent)
return 0;
const QString baseDir = QFileInfo(path()).path();
foreach (FolderNode *fn, parent->subFolderNodes())
if (fn->path() == baseDir + QLatin1Char('/') + folderName)
return fn;
return 0;
}
void COutlookFrame::CreateInterface()
{
FolderNode* initFolder = static_cast<FolderNode*>(m_pInterface->SelectNode(0));
initFolder->SelectNode(0);
}
void GenericProjectNode::refresh(QSet<QString> oldFileList)
{
if (oldFileList.isEmpty()) {
// Only do this once
FileNode *projectFilesNode = new FileNode(m_project->filesFileName(),
ProjectFileType,
/* generated = */ false);
FileNode *projectIncludesNode = new FileNode(m_project->includesFileName(),
ProjectFileType,
/* generated = */ false);
FileNode *projectConfigNode = new FileNode(m_project->configFileName(),
ProjectFileType,
/* generated = */ false);
addFileNodes(QList<FileNode *>()
<< projectFilesNode
<< projectIncludesNode
<< projectConfigNode,
this);
}
// Do those separately
oldFileList.remove(m_project->filesFileName());
oldFileList.remove(m_project->includesFileName());
oldFileList.remove(m_project->configFileName());
QSet<QString> newFileList = m_project->files().toSet();
newFileList.remove(m_project->filesFileName());
newFileList.remove(m_project->includesFileName());
newFileList.remove(m_project->configFileName());
QSet<QString> removed = oldFileList;
removed.subtract(newFileList);
QSet<QString> added = newFileList;
added.subtract(oldFileList);
QString baseDir = QFileInfo(path()).absolutePath();
QHash<QString, QStringList> filesInPaths = sortFilesIntoPaths(baseDir, added);
foreach (const QString &filePath, filesInPaths.keys()) {
QStringList components = filePath.split(QLatin1Char('/'));
FolderNode *folder = findFolderByName(components, components.size());
if (!folder)
folder = createFolderByName(components, components.size());
QList<FileNode *> fileNodes;
foreach (const QString &file, filesInPaths.value(filePath)) {
FileType fileType = SourceType; // ### FIXME
FileNode *fileNode = new FileNode(file, fileType, /*generated = */ false);
fileNodes.append(fileNode);
}
addFileNodes(fileNodes, folder);
}
filesInPaths = sortFilesIntoPaths(baseDir, removed);
foreach (const QString &filePath, filesInPaths.keys()) {
QStringList components = filePath.split(QLatin1Char('/'));
FolderNode *folder = findFolderByName(components, components.size());
QList<FileNode *> fileNodes;
foreach (const QString &file, filesInPaths.value(filePath)) {
foreach (FileNode *fn, folder->fileNodes())
if (fn->path() == file)
fileNodes.append(fn);
}
removeFileNodes(fileNodes, folder);
}
foreach (FolderNode *fn, subFolderNodes())
removeEmptySubFolders(this, fn);
}
