projectmodels.cpp 12.1 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 107 108 109
            break;
        }
        case Qt::DecorationRole: {
            if (folderNode)
                result = folderNode->icon();
            else
110
                result = Core::FileIconProvider::icon(node->filePath().toString());
con's avatar
con committed
111 112 113 114
            break;
        }
        case Qt::FontRole: {
            QFont font;
115
            if (Project *project = SessionManager::startupProject()) {
hjk's avatar
hjk committed
116
                if (node == project->containerNode())
117 118
                    font.setBold(true);
            }
con's avatar
con committed
119 120 121
            result = font;
            break;
        }
122
        case Project::FilePathRole: {
123
            result = node->filePath().toString();
con's avatar
con committed
124 125
            break;
        }
126
        case Project::EnabledRole: {
127 128 129
            result = node->isEnabled();
            break;
        }
con's avatar
con committed
130 131 132 133 134 135
        }
    }

    return result;
}

dt's avatar
dt committed
136 137 138 139 140 141 142
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
143
    Qt::ItemFlags f = Qt::ItemIsSelectable|Qt::ItemIsEnabled|Qt::ItemIsDragEnabled;
144
    if (Node *node = nodeForIndex(index)) {
145
        if (!node->asProjectNode()) {
146
            // either folder or file node
147
            if (node->supportsAction(Rename, node))
148 149 150 151
                f = f | Qt::ItemIsEditable;
        }
    }
    return f;
dt's avatar
dt committed
152 153 154 155 156 157 158 159 160
}

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

161
    Node *node = nodeForIndex(index);
162
    QTC_ASSERT(node, return false);
163

164
    Utils::FileName orgFilePath = node->filePath();
165
    Utils::FileName newFilePath = orgFilePath.parentDir().appendPath(value.toString());
166

167
    ProjectExplorerPlugin::renameFile(node, newFilePath.toString());
168
    emit renamed(orgFilePath, newFilePath);
dt's avatar
dt committed
169 170 171
    return true;
}

172
void FlatModel::addOrRebuildProjectModel(Project *project)
con's avatar
con committed
173
{
174 175 176 177 178 179 180
    WrapperNode *container = nodeForProject(project);
    if (container) {
        container->removeChildren();
    } else {
        container = new WrapperNode(project->containerNode());
        rootItem()->appendChild(container);
    }
hjk's avatar
hjk committed
181

182
    QSet<Node *> seen;
con's avatar
con committed
183

184 185 186 187 188 189
    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
190 191
    }

192
    container->forAllChildren([this](WrapperNode *node) {
hjk's avatar
hjk committed
193 194 195 196 197 198 199
        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 {
200
            emit requestExpansion(node->index());
hjk's avatar
hjk committed
201
        }
202
    });
203 204 205 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

    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
234 235
}

236
void FlatModel::onCollapsed(const QModelIndex &idx)
con's avatar
con committed
237
{
238
    m_toExpand.remove(expandDataForNode(nodeForIndex(idx)));
con's avatar
con committed
239 240
}

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

246
ExpandData FlatModel::expandDataForNode(const Node *node) const
con's avatar
con committed
247
{
248 249 250 251
    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
252 253
}

254
void FlatModel::handleProjectAdded(Project *project)
con's avatar
con committed
255
{
256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271
    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
272 273
}

274
void FlatModel::loadExpandData()
con's avatar
con committed
275
{
276 277 278
    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
279 280
}

281
void FlatModel::saveExpandData()
con's avatar
con committed
282
{
283 284 285
    // 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
286 287
}

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

312 313 314 315 316
Qt::DropActions FlatModel::supportedDragActions() const
{
    return Qt::MoveAction;
}

317 318
QStringList FlatModel::mimeTypes() const
{
319
    return Utils::DropSupport::mimeTypesForFilePaths();
320 321 322 323
}

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

335
WrapperNode *FlatModel::wrapperForNode(const Node *node) const
con's avatar
con committed
336
{
337 338 339 340
    return findNonRooItem([this, node](WrapperNode *item) {
        return item->m_node == node;
    });
}
con's avatar
con committed
341

342 343 344 345
QModelIndex FlatModel::indexForNode(const Node *node) const
{
    WrapperNode *wrapper = wrapperForNode(node);
    return wrapper ? indexForItem(wrapper) : QModelIndex();
con's avatar
con committed
346 347 348 349
}

void FlatModel::setProjectFilterEnabled(bool filter)
{
350 351
    if (filter == m_filterProjects)
        return;
con's avatar
con committed
352
    m_filterProjects = filter;
353
    rebuildModel();
con's avatar
con committed
354 355 356 357 358
}

void FlatModel::setGeneratedFilesFilterEnabled(bool filter)
{
    m_filterGeneratedFiles = filter;
359
    rebuildModel();
con's avatar
con committed
360 361
}

362 363 364 365 366 367 368 369 370 371
bool FlatModel::projectFilterEnabled()
{
    return m_filterProjects;
}

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

con's avatar
con committed
372 373
Node *FlatModel::nodeForIndex(const QModelIndex &index) const
{
374 375
    WrapperNode *flatNode = itemForIndex(index);
    return flatNode ? flatNode->m_node : nullptr;
con's avatar
con committed
376 377
}

378 379 380 381 382 383
const QLoggingCategory &FlatModel::logger()
{
    static QLoggingCategory logger("qtc.projectexplorer.flatmodel");
    return logger;
}

384 385 386 387 388 389 390 391 392 393 394
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);
}

}
395 396

} // namespace ProjectExplorer
397