projectmodels.cpp 12.3 KB
Newer Older
hjk's avatar
hjk committed
1
/****************************************************************************
con's avatar
con committed
2
**
3 4
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
con's avatar
con committed
5
**
hjk's avatar
hjk committed
6
** This file is part of Qt Creator.
con's avatar
con committed
7
**
hjk's avatar
hjk committed
8 9 10 11
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
12 13 14
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
15
**
16 17 18 19 20 21 22
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 as published by the Free Software
** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
con's avatar
con committed
23
**
hjk's avatar
hjk committed
24
****************************************************************************/
hjk's avatar
hjk committed
25

con's avatar
con committed
26
#include "projectmodels.h"
hjk's avatar
hjk committed
27 28

#include "project.h"
29
#include "projectnodes.h"
dt's avatar
dt committed
30
#include "projectexplorer.h"
31
#include "projecttree.h"
32
#include "session.h"
con's avatar
con committed
33 34

#include <coreplugin/fileiconprovider.h>
35
#include <utils/algorithm.h>
36
#include <utils/dropsupport.h>
hjk's avatar
hjk committed
37

38 39 40
#include <QDebug>
#include <QFileInfo>
#include <QFont>
41
#include <QMimeData>
42
#include <QLoggingCategory>
con's avatar
con committed
43

44 45
using namespace Utils;

46 47 48
namespace ProjectExplorer {

using namespace Internal;
con's avatar
con committed
49

50
static bool sortNodes(const Node *n1, const Node *n2)
hjk's avatar
hjk committed
51
{
52 53 54
    if (n1->priority() > n2->priority())
        return true;
    if (n1->priority() < n2->priority())
hjk's avatar
hjk committed
55
        return false;
con's avatar
con committed
56

57 58 59
    const int displayNameResult = caseFriendlyCompare(n1->displayName(), n2->displayName());
    if (displayNameResult != 0)
        return displayNameResult < 0;
con's avatar
con committed
60

61 62 63 64 65
    const int filePathResult = caseFriendlyCompare(n1->filePath().toString(),
                                 n2->filePath().toString());
    if (filePathResult != 0)
        return filePathResult < 0;
    return n1 < n2; // sort by pointer value
con's avatar
con committed
66 67
}

68 69 70 71
static bool sortWrapperNodes(const WrapperNode *w1, const WrapperNode *w2)
{
    return sortNodes(w1->m_node, w2->m_node);
}
hjk's avatar
hjk committed
72

73
FlatModel::FlatModel(QObject *parent)
hjk's avatar
hjk committed
74
    : TreeModel<WrapperNode, WrapperNode>(new WrapperNode(nullptr), parent)
con's avatar
con committed
75
{
76
    ProjectTree *tree = ProjectTree::instance();
77
    connect(tree, &ProjectTree::subtreeChanged, this, &FlatModel::updateSubtree);
con's avatar
con committed
78

79
    SessionManager *sm = SessionManager::instance();
80 81
    connect(sm, &SessionManager::projectRemoved, this, &FlatModel::handleProjectRemoved);
    connect(sm, &SessionManager::aboutToLoadSession, this, &FlatModel::loadExpandData);
82 83
    connect(sm, &SessionManager::aboutToSaveSession, this, &FlatModel::saveExpandData);
    connect(sm, &SessionManager::projectAdded, this, &FlatModel::handleProjectAdded);
84
    connect(sm, &SessionManager::startupProjectChanged, this, [this] { layoutChanged(); });
con's avatar
con committed
85 86 87 88 89 90 91
}

QVariant FlatModel::data(const QModelIndex &index, int role) const
{
    QVariant result;

    if (Node *node = nodeForIndex(index)) {
92
        FolderNode *folderNode = node->asFolderNode();
con's avatar
con committed
93
        switch (role) {
94
        case Qt::DisplayRole: {
hjk's avatar
hjk committed
95
            result = node->displayName();
96 97
            break;
        }
con's avatar
con committed
98
        case Qt::EditRole: {
99
            result = node->filePath().fileName();
con's avatar
con committed
100 101 102
            break;
        }
        case Qt::ToolTipRole: {
103
            result = node->tooltip();
con's avatar
con committed
104 105 106
            break;
        }
        case Qt::DecorationRole: {
107
            if (folderNode) {
con's avatar
con committed
108
                result = folderNode->icon();
109 110 111 112 113
                if (ContainerNode *containerNode = folderNode->asContainerNode()) {
                    if (ProjectNode *projectNode = containerNode->rootProjectNode())
                        result = projectNode->icon();
                }
            } else {
114
                result = Core::FileIconProvider::icon(node->filePath().toString());
115
            }
con's avatar
con committed
116 117 118 119
            break;
        }
        case Qt::FontRole: {
            QFont font;
120
            if (Project *project = SessionManager::startupProject()) {
hjk's avatar
hjk committed
121
                if (node == project->containerNode())
122 123
                    font.setBold(true);
            }
con's avatar
con committed
124 125 126
            result = font;
            break;
        }
127
        case Project::FilePathRole: {
128
            result = node->filePath().toString();
con's avatar
con committed
129 130
            break;
        }
131
        case Project::EnabledRole: {
132 133 134
            result = node->isEnabled();
            break;
        }
con's avatar
con committed
135 136 137 138 139 140
        }
    }

    return result;
}

dt's avatar
dt committed
141 142 143 144 145 146 147
Qt::ItemFlags FlatModel::flags(const QModelIndex &index) const
{
    if (!index.isValid())
        return 0;
    // We claim that everything is editable
    // That's slightly wrong
    // We control the only view, and that one does the checks
148
    Qt::ItemFlags f = Qt::ItemIsSelectable|Qt::ItemIsEnabled|Qt::ItemIsDragEnabled;
149
    if (Node *node = nodeForIndex(index)) {
150
        if (!node->asProjectNode()) {
151
            // either folder or file node
152
            if (node->supportsAction(Rename, node))
153 154 155 156
                f = f | Qt::ItemIsEditable;
        }
    }
    return f;
dt's avatar
dt committed
157 158 159 160 161 162 163 164 165
}

bool FlatModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
    if (!index.isValid())
        return false;
    if (role != Qt::EditRole)
        return false;

166
    Node *node = nodeForIndex(index);
167
    QTC_ASSERT(node, return false);
168

169
    Utils::FileName orgFilePath = node->filePath();
170
    Utils::FileName newFilePath = orgFilePath.parentDir().appendPath(value.toString());
171

172
    ProjectExplorerPlugin::renameFile(node, newFilePath.toString());
173
    emit renamed(orgFilePath, newFilePath);
dt's avatar
dt committed
174 175 176
    return true;
}

177
void FlatModel::addOrRebuildProjectModel(Project *project)
con's avatar
con committed
178
{
179 180 181 182 183 184 185
    WrapperNode *container = nodeForProject(project);
    if (container) {
        container->removeChildren();
    } else {
        container = new WrapperNode(project->containerNode());
        rootItem()->appendChild(container);
    }
hjk's avatar
hjk committed
186

187
    QSet<Node *> seen;
con's avatar
con committed
188

189 190 191 192 193 194
    if (ProjectNode *projectNode = project->rootProjectNode()) {
        addFolderNode(container, projectNode, &seen);
    } else {
        FileNode *projectFileNode = new FileNode(project->projectFilePath(), FileType::Project, false);
        seen.insert(projectFileNode);
        container->appendChild(new WrapperNode(projectFileNode));
con's avatar
con committed
195 196
    }

197
    container->forAllChildren([this](WrapperNode *node) {
hjk's avatar
hjk committed
198 199 200 201 202 203 204
        if (node->m_node) {
            const QString path = node->m_node->filePath().toString();
            const QString displayName = node->m_node->displayName();
            ExpandData ed(path, displayName);
            if (m_toExpand.contains(ed))
                emit requestExpansion(node->index());
        } else {
205
            emit requestExpansion(node->index());
hjk's avatar
hjk committed
206
        }
207
    });
208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238

    const QString path = container->m_node->filePath().toString();
    const QString displayName = container->m_node->displayName();
    ExpandData ed(path, displayName);
    if (m_toExpand.contains(ed))
        emit requestExpansion(container->index());
}

void FlatModel::updateSubtree(FolderNode *node)
{
    // FIXME: This is still excessive, should be limited to the affected subtree.
    while (FolderNode *parent = node->parentFolderNode())
        node = parent;
    if (ContainerNode *container = node->asContainerNode())
        addOrRebuildProjectModel(container->project());
}

void FlatModel::rebuildModel()
{
    QList<Project *> projects = SessionManager::projects();
    QTC_CHECK(projects.size() == rootItem()->childCount());

    Utils::sort(projects, [](Project *p1, Project *p2) {
        const int displayNameResult = caseFriendlyCompare(p1->displayName(), p2->displayName());
        if (displayNameResult != 0)
            return displayNameResult < 0;
        return p1 < p2; // sort by pointer value
    });

    for (Project *project : projects)
        addOrRebuildProjectModel(project);
con's avatar
con committed
239 240
}

241
void FlatModel::onCollapsed(const QModelIndex &idx)
con's avatar
con committed
242
{
243
    m_toExpand.remove(expandDataForNode(nodeForIndex(idx)));
con's avatar
con committed
244 245
}

246
void FlatModel::onExpanded(const QModelIndex &idx)
con's avatar
con committed
247
{
248
    m_toExpand.insert(expandDataForNode(nodeForIndex(idx)));
con's avatar
con committed
249 250
}

251
ExpandData FlatModel::expandDataForNode(const Node *node) const
con's avatar
con committed
252
{
253 254 255 256
    QTC_ASSERT(node, return ExpandData());
    const QString path = node->filePath().toString();
    const QString displayName = node->displayName();
    return ExpandData(path, displayName);
con's avatar
con committed
257 258
}

259
void FlatModel::handleProjectAdded(Project *project)
con's avatar
con committed
260
{
261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
    addOrRebuildProjectModel(project);
}

void FlatModel::handleProjectRemoved(Project *project)
{
    destroyItem(nodeForProject(project));
}

WrapperNode *FlatModel::nodeForProject(Project *project)
{
    QTC_ASSERT(project, return nullptr);
    ContainerNode *containerNode = project->containerNode();
    QTC_ASSERT(containerNode, return nullptr);
    return rootItem()->findFirstLevelChild([containerNode](WrapperNode *node) {
        return node->m_node == containerNode;
    });
con's avatar
con committed
277 278
}

279
void FlatModel::loadExpandData()
con's avatar
con committed
280
{
281 282 283
    const QList<QVariant> data = SessionManager::value("ProjectTree.ExpandData").value<QList<QVariant>>();
    m_toExpand = Utils::transform<QSet>(data, [](const QVariant &v) { return ExpandData::fromSettings(v); });
    m_toExpand.remove(ExpandData());
con's avatar
con committed
284 285
}

286
void FlatModel::saveExpandData()
con's avatar
con committed
287
{
288 289 290
    // TODO if there are multiple ProjectTreeWidgets, the last one saves the data
    QList<QVariant> data = Utils::transform<QList>(m_toExpand, &ExpandData::toSettings);
    SessionManager::setValue(QLatin1String("ProjectTree.ExpandData"), data);
con's avatar
con committed
291 292
}

293
void FlatModel::addFolderNode(WrapperNode *parent, FolderNode *folderNode, QSet<Node *> *seen)
con's avatar
con committed
294
{
295 296
    for (Node *node : folderNode->nodes()) {
        if (FolderNode *subFolderNode = node->asFolderNode()) {
297 298
            const bool isHidden = m_filterProjects && !subFolderNode->showInSimpleTree();
            if (!isHidden && !seen->contains(subFolderNode)) {
299 300 301 302 303 304 305 306
                seen->insert(subFolderNode);
                auto node = new WrapperNode(subFolderNode);
                parent->appendChild(node);
                addFolderNode(node, subFolderNode, seen);
                node->sortChildren(&sortWrapperNodes);
            } else {
                addFolderNode(parent, subFolderNode, seen);
            }
307 308 309
        } else if (FileNode *fileNode = node->asFileNode()) {
            const bool isHidden = m_filterProjects && fileNode->isGenerated();
            if (!isHidden && !seen->contains(fileNode)) {
310 311 312
                seen->insert(fileNode);
                parent->appendChild(new WrapperNode(fileNode));
            }
313 314
        }
    }
con's avatar
con committed
315 316
}

317 318 319 320 321
Qt::DropActions FlatModel::supportedDragActions() const
{
    return Qt::MoveAction;
}

322 323
QStringList FlatModel::mimeTypes() const
{
324
    return Utils::DropSupport::mimeTypesForFilePaths();
325 326 327 328
}

QMimeData *FlatModel::mimeData(const QModelIndexList &indexes) const
{
329
    auto data = new Utils::DropMimeData;
330
    foreach (const QModelIndex &index, indexes) {
331 332 333 334 335
        if (Node *node = nodeForIndex(index)) {
            if (node->asFileNode())
                data->addFile(node->filePath().toString());
            data->addValue(QVariant::fromValue(node));
        }
336
    }
337
    return data;
338 339
}

340
WrapperNode *FlatModel::wrapperForNode(const Node *node) const
con's avatar
con committed
341
{
342 343 344 345
    return findNonRooItem([this, node](WrapperNode *item) {
        return item->m_node == node;
    });
}
con's avatar
con committed
346

347 348 349 350
QModelIndex FlatModel::indexForNode(const Node *node) const
{
    WrapperNode *wrapper = wrapperForNode(node);
    return wrapper ? indexForItem(wrapper) : QModelIndex();
con's avatar
con committed
351 352 353 354
}

void FlatModel::setProjectFilterEnabled(bool filter)
{
355 356
    if (filter == m_filterProjects)
        return;
con's avatar
con committed
357
    m_filterProjects = filter;
358
    rebuildModel();
con's avatar
con committed
359 360 361 362 363
}

void FlatModel::setGeneratedFilesFilterEnabled(bool filter)
{
    m_filterGeneratedFiles = filter;
364
    rebuildModel();
con's avatar
con committed
365 366
}

367 368 369 370 371 372 373 374 375 376
bool FlatModel::projectFilterEnabled()
{
    return m_filterProjects;
}

bool FlatModel::generatedFilesFilterEnabled()
{
    return m_filterGeneratedFiles;
}

con's avatar
con committed
377 378
Node *FlatModel::nodeForIndex(const QModelIndex &index) const
{
379 380
    WrapperNode *flatNode = itemForIndex(index);
    return flatNode ? flatNode->m_node : nullptr;
con's avatar
con committed
381 382
}

383 384 385 386 387 388
const QLoggingCategory &FlatModel::logger()
{
    static QLoggingCategory logger("qtc.projectexplorer.flatmodel");
    return logger;
}

389 390 391 392 393 394 395 396 397 398 399
namespace Internal {

int caseFriendlyCompare(const QString &a, const QString &b)
{
    int result = a.compare(b, Qt::CaseInsensitive);
    if (result != 0)
        return result;
    return a.compare(b, Qt::CaseSensitive);
}

}
400 401

} // namespace ProjectExplorer
402