projectmodels.cpp 11.5 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::update);
con's avatar
con committed
78

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

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

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

    return result;
}

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

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

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

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

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

173
void FlatModel::update()
con's avatar
con committed
174
{
175
    rebuildModel();
con's avatar
con committed
176 177
}

178
void FlatModel::rebuildModel()
con's avatar
con committed
179
{
hjk's avatar
hjk committed
180 181 182 183 184 185 186 187 188
    QList<Project *> projects = SessionManager::projects();

    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
    });

189
    QSet<Node *> seen;
con's avatar
con committed
190

191
    rootItem()->removeChildren();
hjk's avatar
hjk committed
192 193 194 195 196 197 198 199 200 201
    for (Project *project : projects) {
        WrapperNode *container = new WrapperNode(project->containerNode());

        ProjectNode *projectNode = project->rootProjectNode();
        if (projectNode) {
            addFolderNode(container, projectNode, &seen);
        } else {
            FileNode *projectFileNode = new FileNode(project->projectFilePath(), FileType::Project, false);
            seen.insert(projectFileNode);
            container->appendChild(new WrapperNode(projectFileNode));
202
        }
hjk's avatar
hjk committed
203 204 205

        container->sortChildren(&sortWrapperNodes);
        rootItem()->appendChild(container);
con's avatar
con committed
206 207
    }

208
    forAllItems([this](WrapperNode *node) {
hjk's avatar
hjk committed
209 210 211 212 213 214 215
        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 {
216
            emit requestExpansion(node->index());
hjk's avatar
hjk committed
217
        }
218
    });
con's avatar
con committed
219 220
}

221
void FlatModel::onCollapsed(const QModelIndex &idx)
con's avatar
con committed
222
{
223
    m_toExpand.remove(expandDataForNode(nodeForIndex(idx)));
con's avatar
con committed
224 225
}

226
void FlatModel::onExpanded(const QModelIndex &idx)
con's avatar
con committed
227
{
228
    m_toExpand.insert(expandDataForNode(nodeForIndex(idx)));
con's avatar
con committed
229 230
}

231
ExpandData FlatModel::expandDataForNode(const Node *node) const
con's avatar
con committed
232
{
233 234 235 236
    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
237 238
}

239
void FlatModel::handleProjectAdded(Project *project)
con's avatar
con committed
240
{
241
    Node *node = project->containerNode();
242 243 244 245 246
    m_toExpand.insert(expandDataForNode(node));
    if (WrapperNode *wrapper = wrapperForNode(node)) {
        wrapper->forFirstLevelChildren([this](WrapperNode *child) {
            m_toExpand.insert(expandDataForNode(child->m_node));
        });
con's avatar
con committed
247
    }
248
    update();
con's avatar
con committed
249 250
}

251
void FlatModel::loadExpandData()
con's avatar
con committed
252
{
253 254 255
    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
256 257
}

258
void FlatModel::saveExpandData()
con's avatar
con committed
259
{
260 261 262
    // 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
263 264
}

265
void FlatModel::addFolderNode(WrapperNode *parent, FolderNode *folderNode, QSet<Node *> *seen)
con's avatar
con committed
266
{
267 268 269 270 271 272 273 274 275 276 277
    for (Node *node : folderNode->nodes()) {
        if (FolderNode *subFolderNode = node->asFolderNode()) {
            if (!filter(subFolderNode) && !seen->contains(subFolderNode)) {
                seen->insert(subFolderNode);
                auto node = new WrapperNode(subFolderNode);
                parent->appendChild(node);
                addFolderNode(node, subFolderNode, seen);
                node->sortChildren(&sortWrapperNodes);
            } else {
                addFolderNode(parent, subFolderNode, seen);
            }
278 279
        }
    }
280 281 282 283 284 285
    for (Node *node : folderNode->nodes()) {
        if (FileNode *fileNode = node->asFileNode()) {
            if (!filter(fileNode) && !seen->contains(fileNode)) {
                seen->insert(fileNode);
                parent->appendChild(new WrapperNode(fileNode));
            }
286 287
        }
    }
con's avatar
con committed
288 289
}

290 291 292 293 294
Qt::DropActions FlatModel::supportedDragActions() const
{
    return Qt::MoveAction;
}

295 296
QStringList FlatModel::mimeTypes() const
{
297
    return Utils::DropSupport::mimeTypesForFilePaths();
298 299 300 301
}

QMimeData *FlatModel::mimeData(const QModelIndexList &indexes) const
{
302
    auto data = new Utils::DropMimeData;
303
    foreach (const QModelIndex &index, indexes) {
304 305 306 307 308
        if (Node *node = nodeForIndex(index)) {
            if (node->asFileNode())
                data->addFile(node->filePath().toString());
            data->addValue(QVariant::fromValue(node));
        }
309
    }
310
    return data;
311 312
}

313
WrapperNode *FlatModel::wrapperForNode(const Node *node) const
con's avatar
con committed
314
{
315 316 317 318
    return findNonRooItem([this, node](WrapperNode *item) {
        return item->m_node == node;
    });
}
con's avatar
con committed
319

320 321 322 323
QModelIndex FlatModel::indexForNode(const Node *node) const
{
    WrapperNode *wrapper = wrapperForNode(node);
    return wrapper ? indexForItem(wrapper) : QModelIndex();
con's avatar
con committed
324 325 326 327
}

void FlatModel::setProjectFilterEnabled(bool filter)
{
328 329
    if (filter == m_filterProjects)
        return;
con's avatar
con committed
330
    m_filterProjects = filter;
331
    rebuildModel();
con's avatar
con committed
332 333 334 335 336
}

void FlatModel::setGeneratedFilesFilterEnabled(bool filter)
{
    m_filterGeneratedFiles = filter;
337
    rebuildModel();
con's avatar
con committed
338 339
}

340 341 342 343 344 345 346 347 348 349
bool FlatModel::projectFilterEnabled()
{
    return m_filterProjects;
}

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

con's avatar
con committed
350 351
Node *FlatModel::nodeForIndex(const QModelIndex &index) const
{
352 353
    WrapperNode *flatNode = itemForIndex(index);
    return flatNode ? flatNode->m_node : nullptr;
con's avatar
con committed
354 355 356 357 358
}

bool FlatModel::filter(Node *node) const
{
    bool isHidden = false;
359
    if (FolderNode *folderNode = node->asFolderNode()) {
360
        if (m_filterProjects)
361
            isHidden = !folderNode->showInSimpleTree();
362
    } else if (FileNode *fileNode = node->asFileNode()) {
con's avatar
con committed
363 364 365 366 367 368
        if (m_filterGeneratedFiles)
            isHidden = fileNode->isGenerated();
    }
    return isHidden;
}

369 370 371 372 373 374
const QLoggingCategory &FlatModel::logger()
{
    static QLoggingCategory logger("qtc.projectexplorer.flatmodel");
    return logger;
}

375 376 377 378 379 380 381 382 383 384 385
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);
}

}
386 387

} // namespace ProjectExplorer
388