feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

Revert "Toolchains: Make options page more stable."

Browse Source 
This reverts commit 373000a954.
This commit is contained in:
dt
2011-02-23 16:07:57 +01:00
parent 63fb8ffc9a
commit 5e2171bd29
2 changed files with 101 additions and 99 deletions
Download Patch File Download Diff File Expand all files Collapse all files

188
src/plugins/projectexplorer/toolchainoptionspage.cpp
View File

@@ -44,7 +44,6 @@
#include <QtCore/QSignalMapper> #include <QtCore/QSignalMapper>
#include <QtCore/QTextStream> #include <QtCore/QTextStream>
#include <QtGui/QAction> #include <QtGui/QAction>
#include <QtGui/QItemSelectionModel> #include <QtGui/QItemSelectionModel>
#include <QtGui/QLabel> #include <QtGui/QLabel>
@@ -54,14 +53,14 @@
namespace ProjectExplorer { namespace ProjectExplorer {
namespace Internal { namespace Internal {
typedef QSharedPointer<ToolChainNode> ToolChainNodePtr;
class ToolChainNode class ToolChainNode
{ {
public: public:
explicit ToolChainNode(ToolChain *tc = 0, bool c = false) : explicit ToolChainNode(ToolChainNode *p, ToolChain *tc = 0, bool c = false) :
parent(0), toolChain(tc), changed(c) parent(p), toolChain(tc), changed(c)
{ {
if (p)
p->childNodes.append(this);
widget = tc ? tc->configurationWidget() : 0; widget = tc ? tc->configurationWidget() : 0;
if (widget) { if (widget) {
widget->setEnabled(tc ? !tc->isAutoDetected() : false); widget->setEnabled(tc ? !tc->isAutoDetected() : false);
@@ -71,60 +70,39 @@ public:
~ToolChainNode() ~ToolChainNode()
{ {
qDeleteAll(childNodes);
// Do not delete toolchain, we do not own it. // Do not delete toolchain, we do not own it.
delete widget; delete widget;
} }
void addChild(const ToolChainNodePtr &c)
{
c->parent = this;
childNodes.push_back(c);
}
ToolChainNode *parent; ToolChainNode *parent;
QString newName; QString newName;
QList<ToolChainNodePtr> childNodes; QList<ToolChainNode *> childNodes;
ToolChain *toolChain; ToolChain *toolChain;
ToolChainConfigWidget *widget; ToolChainConfigWidget *widget;
bool changed; bool changed;
}; };
static int indexOfToolChain(const QList<ToolChainNodePtr> &l, const ToolChain *tc)
{
const int count = l.size();
for (int i = 0; i < count ; i++)
if (l.at(i)->toolChain == tc)
return i;
return -1;
}
static int indexOfToolChainNode(const QList<ToolChainNodePtr> &l, const ToolChainNode *node)
{
const int count = l.size();
for (int i = 0; i < count ; i++)
if (l.at(i).data() == node)
return i;
return -1;
}
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// ToolChainModel // ToolChainModel
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
ToolChainModel::ToolChainModel(QObject *parent) : ToolChainModel::ToolChainModel(QObject *parent) :
QAbstractItemModel(parent), m_autoRoot(new ToolChainNode), m_manualRoot(new ToolChainNode) QAbstractItemModel(parent)
{ {
connect(ToolChainManager::instance(), SIGNAL(toolChainAdded(ProjectExplorer::ToolChain*)), connect(ToolChainManager::instance(), SIGNAL(toolChainAdded(ProjectExplorer::ToolChain*)),
this, SLOT(addToolChain(ProjectExplorer::ToolChain*))); this, SLOT(addToolChain(ProjectExplorer::ToolChain*)));
connect(ToolChainManager::instance(), SIGNAL(toolChainRemoved(ProjectExplorer::ToolChain*)), connect(ToolChainManager::instance(), SIGNAL(toolChainRemoved(ProjectExplorer::ToolChain*)),
this, SLOT(removeToolChain(ProjectExplorer::ToolChain*))); this, SLOT(removeToolChain(ProjectExplorer::ToolChain*)));
m_autoRoot = new ToolChainNode(0);
m_manualRoot = new ToolChainNode(0);
foreach (ToolChain *tc, ToolChainManager::instance()->toolChains()) { foreach (ToolChain *tc, ToolChainManager::instance()->toolChains()) {
if (tc->isAutoDetected()) { if (tc->isAutoDetected())
m_autoRoot->addChild(ToolChainNodePtr(new ToolChainNode(tc))); new ToolChainNode(m_autoRoot, tc);
} else { else {
ToolChainNodePtr node(new ToolChainNode(tc)); ToolChainNode *node = new ToolChainNode(m_manualRoot, tc);
m_manualRoot->addChild(node);
if (node->widget) if (node->widget)
connect(node->widget, SIGNAL(dirty(ProjectExplorer::ToolChain*)), connect(node->widget, SIGNAL(dirty(ProjectExplorer::ToolChain*)),
this, SLOT(setDirty(ProjectExplorer::ToolChain*))); this, SLOT(setDirty(ProjectExplorer::ToolChain*)));
@@ -134,19 +112,21 @@ ToolChainModel::ToolChainModel(QObject *parent) :
ToolChainModel::~ToolChainModel() ToolChainModel::~ToolChainModel()
{ {
delete m_autoRoot;
delete m_manualRoot;
} }
QModelIndex ToolChainModel::index(int row, int column, const QModelIndex &parent) const QModelIndex ToolChainModel::index(int row, int column, const QModelIndex &parent) const
{ {
if (!parent.isValid()) { if (!parent.isValid()) {
if (row == 0) if (row == 0)
return createIndex(0, 0, static_cast<void *>(m_autoRoot.data())); return createIndex(0, 0, static_cast<void *>(m_autoRoot));
else else
return createIndex(1, 0, static_cast<void *>(m_manualRoot.data())); return createIndex(1, 0, static_cast<void *>(m_manualRoot));
} }
ToolChainNode *node = static_cast<ToolChainNode *>(parent.internalPointer()); ToolChainNode *node = static_cast<ToolChainNode *>(parent.internalPointer());
if (row < node->childNodes.count() && column < 2) if (row < node->childNodes.count() && column < 2)
return createIndex(row, column, static_cast<void *>(node->childNodes.at(row).data())); return createIndex(row, column, static_cast<void *>(node->childNodes.at(row)));
else else
return QModelIndex(); return QModelIndex();
} }
@@ -272,7 +252,7 @@ ToolChainConfigWidget *ToolChainModel::widget(const QModelIndex &index)
bool ToolChainModel::isDirty() const bool ToolChainModel::isDirty() const
{ {
foreach (const ToolChainNodePtr &n, m_manualRoot->childNodes) { foreach (ToolChainNode *n, m_manualRoot->childNodes) {
if (n->changed) if (n->changed)
return true; return true;
} }
@@ -281,7 +261,7 @@ bool ToolChainModel::isDirty() const
bool ToolChainModel::isDirty(ToolChain *tc) const bool ToolChainModel::isDirty(ToolChain *tc) const
{ {
foreach (const ToolChainNodePtr &n, m_manualRoot->childNodes) { foreach (ToolChainNode *n, m_manualRoot->childNodes) {
if (n->toolChain == tc && n->changed) if (n->toolChain == tc && n->changed)
return true; return true;
} }
@@ -290,10 +270,10 @@ bool ToolChainModel::isDirty(ToolChain *tc) const
void ToolChainModel::setDirty(ToolChain *tc) void ToolChainModel::setDirty(ToolChain *tc)
{ {
foreach (const ToolChainNodePtr &n, m_manualRoot->childNodes) { foreach (ToolChainNode *n, m_manualRoot->childNodes) {
if (n->toolChain == tc) { if (n->toolChain == tc) {
n->changed = true; n->changed = true;
emit dataChanged(index(n.data(), 0), index(n.data(), columnCount(QModelIndex()))); emit dataChanged(index(n, 0), index(n, columnCount(QModelIndex())));
} }
} }
} }
@@ -301,15 +281,15 @@ void ToolChainModel::setDirty(ToolChain *tc)
void ToolChainModel::apply() void ToolChainModel::apply()
{ {
// Remove unused ToolChains: // Remove unused ToolChains:
QList<ToolChainNodePtr> nodes = m_toRemoveList; QList<ToolChainNode *> nodes = m_toRemoveList;
foreach (const ToolChainNodePtr &n, nodes) { foreach (ToolChainNode *n, nodes) {
ToolChainManager::instance()->deregisterToolChain(n->toolChain); ToolChainManager::instance()->deregisterToolChain(n->toolChain);
} }
QTC_ASSERT(m_toRemoveList.isEmpty(), /* */ ); Q_ASSERT(m_toRemoveList.isEmpty());
// Update toolchains: // Update toolchains:
foreach (const ToolChainNodePtr &n, m_manualRoot->childNodes) { foreach (ToolChainNode *n, m_manualRoot->childNodes) {
Q_ASSERT(n.data()); Q_ASSERT(n);
if (n->changed) { if (n->changed) {
Q_ASSERT(n->toolChain); Q_ASSERT(n->toolChain);
if (!n->newName.isEmpty()) if (!n->newName.isEmpty())
@@ -318,66 +298,72 @@ void ToolChainModel::apply()
n->widget->apply(); n->widget->apply();
n->changed = false; n->changed = false;
emit dataChanged(index(n.data(), 0), index(n.data(), columnCount(QModelIndex()))); emit dataChanged(index(n, 0), index(n, columnCount(QModelIndex())));
} }
} }
// Add new (and already updated) toolchains // Add new (and already updated) toolchains
nodes = m_toAddList; nodes = m_toAddList;
foreach (const ToolChainNodePtr &n, nodes) { foreach (ToolChainNode *n, nodes) {
ToolChainManager::instance()->registerToolChain(n->toolChain); ToolChainManager::instance()->registerToolChain(n->toolChain);
} }
QTC_ASSERT(m_toAddList.isEmpty(), qDebug() << m_toAddList.front()->toolChain; ); Q_ASSERT(m_toAddList.isEmpty());
} }
void ToolChainModel::discard() void ToolChainModel::discard()
{ {
// Remove newly "added" toolchains: // Remove newly "added" toolchains:
foreach (const ToolChainNodePtr &n, m_toAddList) { foreach (ToolChainNode *n, m_toAddList) {
const int pos = indexOfToolChainNode(m_manualRoot->childNodes, n.data()); int pos = m_manualRoot->childNodes.indexOf(n);
QTC_ASSERT(pos >= 0, continue ; ); Q_ASSERT(pos >= 0);
m_manualRoot->childNodes.removeAt(pos); m_manualRoot->childNodes.removeAt(pos);
// Clean up Node: We still own the toolchain! // Clean up Node: We still own the toolchain!
delete n->toolChain; delete n->toolChain;
n->toolChain = 0; n->toolChain = 0;
} }
qDeleteAll(m_toAddList);
m_toAddList.clear(); m_toAddList.clear();
// Add "removed" toolchains again: // Add "removed" toolchains again:
foreach (const ToolChainNodePtr &n, m_toRemoveList) { foreach (ToolChainNode *n, m_toRemoveList) {
m_manualRoot->addChild(n); m_manualRoot->childNodes.append(n);
} }
m_toRemoveList.clear(); m_toRemoveList.clear();
// Reset toolchains: // Reset toolchains:
foreach (const ToolChainNodePtr &n, m_manualRoot->childNodes) { foreach (ToolChainNode *n, m_manualRoot->childNodes) {
Q_ASSERT(n);
n->newName.clear(); n->newName.clear();
if (n->widget) if (n->widget)
n->widget->discard(); n->widget->discard();
n->changed = false; n->changed = false;
} }
reset();
} }
void ToolChainModel::markForRemoval(ToolChain *tc) void ToolChainModel::markForRemoval(ToolChain *tc)
{ {
// Delete newly added item? ToolChainNode *node = 0;
const int tcIndex = indexOfToolChain(m_manualRoot->childNodes, tc); foreach (ToolChainNode *n, m_manualRoot->childNodes) {
if (tcIndex != -1) { if (n->toolChain == tc) {
m_toRemoveList.append(m_manualRoot->childNodes.at(tcIndex)); node = n;
emit beginRemoveRows(index(m_manualRoot.data()), tcIndex, tcIndex); break;
m_manualRoot->childNodes.removeAt(tcIndex); }
}
if (node) {
m_toRemoveList.append(node);
emit beginRemoveRows(index(m_manualRoot), m_manualRoot->childNodes.indexOf(node), m_manualRoot->childNodes.indexOf(node));
m_manualRoot->childNodes.removeOne(node);
emit endRemoveRows(); emit endRemoveRows();
} }
} }
void ToolChainModel::markForAddition(ToolChain *tc) void ToolChainModel::markForAddition(ToolChain *tc)
{ {
const int pos = m_manualRoot->childNodes.size(); int pos = m_manualRoot->childNodes.size();
emit beginInsertRows(index(m_manualRoot.data()), pos, pos); emit beginInsertRows(index(m_manualRoot), pos, pos);
const ToolChainNodePtr node(new ToolChainNode(tc)); ToolChainNode *node = new ToolChainNode(m_manualRoot, tc);
m_manualRoot->addChild(node);
node->changed = true; node->changed = true;
m_toAddList.append(node); m_toAddList.append(node);
@@ -387,28 +373,29 @@ void ToolChainModel::markForAddition(ToolChain *tc)
QModelIndex ToolChainModel::index(ToolChainNode *node, int column) const QModelIndex ToolChainModel::index(ToolChainNode *node, int column) const
{ {
if (!node->parent) if (!node->parent)
return index(node == m_autoRoot.data() ? 0 : 1, column, QModelIndex()); return index(node == m_autoRoot ? 0 : 1, column, QModelIndex());
else { else
const int tcIndex = indexOfToolChainNode(node->parent->childNodes, node); return index(node->parent->childNodes.indexOf(node), column, index(node->parent));
QTC_ASSERT(tcIndex != -1, return QModelIndex());
return index(tcIndex, column, index(node->parent));
}
} }
void ToolChainModel::addToolChain(ToolChain *tc) void ToolChainModel::addToolChain(ToolChain *tc)
{ {
const int tcIndex = indexOfToolChain(m_toAddList, tc); QList<ToolChainNode *> nodes = m_toAddList;
if (tcIndex != -1) { foreach (ToolChainNode *n, nodes) {
m_toAddList.removeAt(tcIndex); if (n->toolChain == tc) {
m_toAddList.removeOne(n);
// do not delete n: Still used elsewhere!
return; return;
} }
const ToolChainNodePtr parent = tc->isAutoDetected() ? m_autoRoot : m_manualRoot; }
QTC_ASSERT(indexOfToolChain(parent->childNodes, tc) == -1, return ; )
const int row = parent->childNodes.count(); ToolChainNode *parent = m_manualRoot;
beginInsertRows(index(parent.data()), row, row); if (tc->isAutoDetected())
ToolChainNodePtr newNode(new ToolChainNode(tc, true)); parent = m_autoRoot;
parent->addChild(newNode); int row = parent->childNodes.count();
beginInsertRows(index(parent), row, row);
new ToolChainNode(parent, tc, true);
endInsertRows(); endInsertRows();
emit toolChainStateChanged(); emit toolChainStateChanged();
@@ -416,17 +403,32 @@ void ToolChainModel::addToolChain(ToolChain *tc)
void ToolChainModel::removeToolChain(ToolChain *tc) void ToolChainModel::removeToolChain(ToolChain *tc)
{ {
const int tcIndex = indexOfToolChain(m_toRemoveList, tc); QList<ToolChainNode *> nodes = m_toRemoveList;
if (tcIndex != -1) foreach (ToolChainNode *n, nodes) {
m_toRemoveList.removeAt(tcIndex); if (n->toolChain == tc) {
m_toRemoveList.removeOne(n);
const ToolChainNodePtr parent = tc->isAutoDetected() ? m_autoRoot : m_manualRoot; delete n;
const int row = indexOfToolChain(parent->childNodes, tc); return;
if (row != -1) {
beginRemoveRows(index(parent.data()), row, row);
parent->childNodes.removeAt(row);
endRemoveRows();
} }
}
ToolChainNode *parent = m_manualRoot;
if (tc->isAutoDetected())
parent = m_autoRoot;
int row = 0;
ToolChainNode *node = 0;
foreach (ToolChainNode *current, parent->childNodes) {
if (current->toolChain == tc) {
node = current;
break;
}
++row;
}
beginRemoveRows(index(parent), row, row);
parent->childNodes.removeAt(row);
delete node;
endRemoveRows();
emit toolChainStateChanged(); emit toolChainStateChanged();
} }

10
src/plugins/projectexplorer/toolchainoptionspage.h
View File

@@ -39,7 +39,6 @@
#include <coreplugin/dialogs/ioptionspage.h> #include <coreplugin/dialogs/ioptionspage.h>
#include <QtCore/QAbstractItemModel> #include <QtCore/QAbstractItemModel>
#include <QtCore/QSharedPointer>
QT_BEGIN_NAMESPACE QT_BEGIN_NAMESPACE
class QTreeWidgetItem; class QTreeWidgetItem;
@@ -102,11 +101,12 @@ private slots:
private: private:
QModelIndex index(ToolChainNode *, int column = 0) const; QModelIndex index(ToolChainNode *, int column = 0) const;
QSharedPointer<ToolChainNode> m_autoRoot; ToolChainNode * m_root;
QSharedPointer<ToolChainNode> m_manualRoot; ToolChainNode * m_autoRoot;
ToolChainNode * m_manualRoot;
QList<QSharedPointer<ToolChainNode> > m_toAddList; QList<ToolChainNode *> m_toAddList;
QList<QSharedPointer<ToolChainNode> > m_toRemoveList; QList<ToolChainNode *> m_toRemoveList;
}; };
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------