tools/qconfig/featuretreemodel.cpp

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the tools applications of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #include "featuretreemodel.h"
  43 #include "feature.h"
  44 #include <QPalette>
  45 #include <QColor>
  46 #include <QApplication>
  47 #include <QtDebug>
  48
  49 QT_BEGIN_NAMESPACE
  50
  51 class Node
  52 {
  53 public:
  54     Node(Feature *f, Node *p = 0) : feature(f), parent(p) {}
  55     ~Node();
  56     Node* find(const Feature *child) const;
  57     bool contains(const Feature *child) const { return find(child) != 0; }
  58     bool insert(Node *n);
  59
  60     Feature *feature;
  61     Node *parent;
  62     QList<Node*> children; // maybe convert to Map to get keys sorted
  63 };
  64
  65 Node::~Node()
  66 {
  67     while (!children.isEmpty())
  68         delete children.takeFirst();
  69 }
  70
  71 Node* Node::find(const Feature *f) const
  72 {
  73     if (this->feature == f)
  74         return const_cast<Node*>(this);
  75
  76     foreach (Node *n, children)
  77         if (Node *m = n->find(f))
  78             return m;
  79
  80     return 0;
  81 }
  82
  83 static bool nodePtrLessThan(const Node *n1, const Node *n2)
  84 {
  85     return (n1->feature->key() < n2->feature->key());
  86 }
  87
  88 /*
  89   Try insert \a n into the tree with this node as root.
  90   n is inserted as a child if it has a dependency to this node.
  91   Returns true if child is inserted into the tree, false otherwise.
  92 */
  93 bool Node::insert(Node *n)
  94 {
  95     Feature *f = const_cast<Feature*>(n->feature);
  96     if (feature->supports().contains(f)) {
  97         children.append(n);
  98         qSort(children.begin(), children.end(), nodePtrLessThan);
  99         n->parent = this;
 100         return true;
 101     }
 102     foreach (Node *child, children)
 103         if (child->insert(n))
 104             return true;
 105     return false;
 106 }
 107
 108 static bool isSection(const QModelIndex &index)
 109 {
 110     return index.isValid() && (index.internalId() == 0);
 111 }
 112
 113 FeatureTreeModel::FeatureTreeModel(QObject *parent)
 114     : QAbstractItemModel(parent)
 115 {
 116 }
 117
 118 FeatureTreeModel::~FeatureTreeModel()
 119 {
 120     foreach (QString section, sections.keys())
 121         while (!sections[section].isEmpty())
 122             delete sections[section].takeFirst();
 123 }
 124
 125 /*
 126   Returns true if the model already contains \a in \a section, false otherwise.
 127 */
 128 bool FeatureTreeModel::contains(const QString &section, const Feature *f) const
 129 {
 130     return (find(section, f) != 0);
 131 }
 132
 133 Node* FeatureTreeModel::find(const QString &section, const Feature *f) const
 134 {
 135     QList<Node*> roots = sections[section];
 136     foreach (Node *root, roots)
 137         if (Node *n = root->find(f))
 138             return n;
 139     return 0;
 140 }
 141
 142 /*
 143   Add new \a feature to the tree.
 144   When all feature is added, buildTree() must be called to build the
 145   dependency tree.
 146 */
 147 void FeatureTreeModel::addFeature(Feature *feature)
 148 {
 149     const QString section = feature->section();
 150     Q_ASSERT(!contains(section, feature));
 151
 152     connect(feature, SIGNAL(changed()), this, SLOT(featureChanged()));
 153
 154     Node *node = new Node(feature, 0);
 155
 156     // try insert any toplevel nodes as child of this one
 157     foreach (Node *n, sections[section])
 158         if (node->insert(n))
 159             sections[section].removeAll(n);
 160
 161     // try insert this node as a child of any existing node
 162     foreach (Node *n, sections[section])
 163         if (n->insert(node)) {
 164             emit layoutChanged();
 165             return;
 166         }
 167
 168     // not a child, insert as a toplevel node
 169     sections[section].append(node);
 170     qSort(sections[section].begin(), sections[section].end(), nodePtrLessThan);
 171     emit layoutChanged();
 172 }
 173
 174 QModelIndex FeatureTreeModel::createIndex(int row, int column,
 175                                           const QModelIndex &parent,
 176                                           const Node *node) const
 177 {
 178     QModelIndex index = QAbstractItemModel::createIndex(row, column,
 179                                                         (void*)node);
 180     if (parent.isValid())
 181         parentMap[index] = parent;
 182     if (node)
 183         featureIndexMap[node->feature] = index;
 184     return index;
 185 }
 186
 187 QModelIndex FeatureTreeModel::index(int row, int column,
 188                                     const QModelIndex &parent) const
 189 {
 190     if (!parent.isValid()) { // index is a section
 191         if (row < sections.size() && column == 0)
 192             return QAbstractItemModel::createIndex(row, column, 0);
 193         return QModelIndex();
 194     }
 195
 196     if (isSection(parent)) { // index is a toplevel feature
 197         const int parentRow = parent.row();
 198         if (parentRow < sections.size()) {
 199             QString section = sections.keys().at(parentRow);
 200             QList<Node*> nodes = sections[section];
 201             if (row < nodes.size() && column < 2)
 202                 return createIndex(row, column, parent, nodes.at(row));
 203         }
 204         return QModelIndex();
 205     }
 206
 207     // parent is a feature
 208     Node *parentNode = static_cast<Node*>(parent.internalPointer());
 209     QList<Node*> children = parentNode->children;
 210     if (row < children.size() && column < 2)
 211         return createIndex(row, column, parent, children.at(row));
 212
 213     return QModelIndex();
 214 }
 215
 216 QModelIndex FeatureTreeModel::index(const QModelIndex &parent,
 217                                     const Feature *feature) const
 218 {
 219     const int rows = rowCount(parent);
 220     for (int i = 0; i < rows; ++i) {
 221         QModelIndex child = index(i, 0, parent);
 222         Node *node = static_cast<Node*>(child.internalPointer());
 223         if (node && node->feature == feature)
 224             return child;
 225         QModelIndex childSearch = index(child, feature);
 226         if (childSearch.isValid())
 227             return childSearch;
 228     }
 229     return QModelIndex();
 230 }
 231
 232 QModelIndex FeatureTreeModel::index(const Feature *feature) const
 233 {
 234     if (featureIndexMap.contains(feature))
 235         return featureIndexMap.value(feature);
 236
 237     // exhaustive search
 238     int sectionRow = sections.keys().indexOf(feature->section());
 239     QModelIndex sectionIndex = index(sectionRow, 0, QModelIndex());
 240
 241     return index(sectionIndex, feature);
 242 }
 243
 244 QModelIndex FeatureTreeModel::parent(const QModelIndex &index) const
 245 {
 246     if (!index.isValid())
 247         return QModelIndex();
 248
 249     if (parentMap.contains(index))
 250         return parentMap.value(index);
 251     return QModelIndex();
 252 }
 253
 254 int FeatureTreeModel::rowCount(const QModelIndex &parent) const
 255 {
 256     if (!parent.isValid())
 257         return sections.size();
 258
 259     if (isSection(parent)) {
 260         const QString section = sections.keys().at(parent.row());
 261         return sections[section].size();
 262     }
 263
 264     const Node *node = static_cast<Node*>(parent.internalPointer());
 265     return node->children.size();
 266 }
 267
 268 int FeatureTreeModel::columnCount(const QModelIndex &parent) const
 269 {
 270 #if 0
 271     if (!parent.isValid())
 272         return 0;
 273
 274     if (isSection(parent))
 275        return 1;
 276 #endif
 277     Q_UNUSED(parent);
 278     return 2; // Feature: [key, name]
 279 }
 280
 281 QVariant FeatureTreeModel::data(const QModelIndex &index, int role) const
 282 {
 283     if (!index.isValid())
 284         return QVariant();
 285
 286     const Node *node = static_cast<Node*>(index.internalPointer());
 287
 288     switch (role) {
 289         case Qt::DisplayRole: {
 290             if (node == 0)  // index is a section
 291                 return sections.keys().at(index.row());
 292             if (index.column() == 0)
 293                 return node->feature->key();
 294             Q_ASSERT(index.column() == 1);
 295             return node->feature->title();
 296         }
 297         case Qt::CheckStateRole: {
 298             if (node && index.column() == 0)
 299                 return (node->feature->enabled() ?
 300                         Qt::Checked : Qt::Unchecked);
 301             break;
 302         }
 303         case Qt::TextColorRole: {
 304             if (node && index.column() == 0)  // feature key
 305                 if (node->feature->selectable())
 306                     return QApplication::palette().color(QPalette::Link);
 307             break;
 308         }
 309         case Qt::TextAlignmentRole:
 310         case Qt::BackgroundColorRole:
 311         case Qt::FontRole:
 312         case Qt::ToolTipRole: // TODO
 313         case Qt::StatusTipRole: // TODO
 314         case Qt::WhatsThisRole: // TODO
 315         case Qt::DecorationRole:
 316         case Qt::EditRole:
 317         default:
 318             break;
 319     }
 320     return QVariant();
 321 }
 322
 323 bool FeatureTreeModel::setData(const QModelIndex &index,
 324                                const QVariant &value, int role)
 325 {
 326     if (!index.isValid())
 327         return false;
 328
 329     Node *node = static_cast<Node*>(index.internalPointer());
 330     if (!node)
 331         return false;
 332
 333     if (role == Qt::CheckStateRole) {
 334         Qt::CheckState state = static_cast<Qt::CheckState>(value.toInt());
 335         if (state == Qt::Checked)
 336             node->feature->setEnabled(true);
 337         else if (state == Qt::Unchecked)
 338             node->feature->setEnabled(false);
 339         emit dataChanged(index, index);
 340         return true;
 341     }
 342     return false;
 343 }
 344
 345 Qt::ItemFlags FeatureTreeModel::flags(const QModelIndex &index) const
 346 {
 347     if (!index.isValid() || index.internalPointer() == 0)
 348         return Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 349
 350     const Node *node = static_cast<Node*>(index.internalPointer());
 351     const Feature *feature = node->feature;
 352     Qt::ItemFlags flags = Qt::ItemIsUserCheckable | Qt::ItemIsSelectable;
 353
 354     if (feature->selectable())
 355         flags |= Qt::ItemIsEnabled;
 356
 357     return flags;
 358 }
 359
 360 QVariant FeatureTreeModel::headerData(int section, Qt::Orientation orientation,
 361                                       int role) const
 362 {
 363     if (orientation == Qt::Horizontal && role == Qt::DisplayRole) {
 364         if (section == 0)
 365             return QString("Id");
 366         else if (section == 1)
 367             return QString("Name");
 368     }
 369
 370     return QVariant();
 371 }
 372
 373 Feature* FeatureTreeModel::getFeature(const QModelIndex &index) const
 374 {
 375     if (!index.isValid())
 376         return 0;
 377     if (isSection(index))
 378         return 0;
 379     Node *node = static_cast<Node*>(index.internalPointer());
 380     return const_cast<Feature*>(node->feature);
 381 }
 382
 383 void FeatureTreeModel::featureChanged()
 384 {
 385     Feature *feature = qobject_cast<Feature*>(sender());
 386     if (feature) {
 387         QModelIndex featureIndex = index(feature);
 388         emit dataChanged(featureIndex, featureIndex);
 389     } else {
 390         emit layoutChanged();
 391     }
 392 }
 393
 394 void FeatureTreeModel::readConfig(QTextStream &stream)
 395 {
 396     static QRegExp regexp("\\s*#\\s*define\\s+QT_NO_(\\S+)\\s*");
 397
 398     while (!stream.atEnd()) {
 399         QString line = stream.readLine();
 400         if (regexp.exactMatch(line)) {
 401             Feature *f = Feature::getInstance(regexp.cap(1));
 402             f->setEnabled(false);
 403         }
 404     }
 405 }
 406 /*
 407   Search for all disabled child features of \a parent.
 408   Returns a list of feature keys for the disabled items.
 409 */
 410 QStringList FeatureTreeModel::findDisabled(const QModelIndex &parent) const
 411 {
 412     QStringList stringList;
 413
 414     const int rows = rowCount(parent);
 415     for (int i = 0; i < rows; ++i) {
 416         QModelIndex child = index(i, 0, parent);
 417         Node *node = static_cast<Node*>(child.internalPointer());
 418         if (node && node->feature && !node->feature->enabled())
 419             stringList << node->feature->key();
 420         stringList << findDisabled(child);
 421     }
 422     return stringList;
 423 }
 424
 425 void FeatureTreeModel::writeConfig(QTextStream &stream) const
 426 {
 427     const int sectionCount = rowCount(QModelIndex());
 428
 429     for (int i = 0; i < sectionCount; ++i) {
 430         QModelIndex section = index(i, 0, QModelIndex());
 431         QStringList disabled = findDisabled(section);
 432         if (disabled.size() > 0) {
 433             stream << '\n' << "/* " << sections.keys().at(i) << " */" << '\n';
 434             foreach (QString feature, disabled)
 435                 stream << "#ifndef QT_NO_" << feature << '\n'
 436                        << "#  define QT_NO_" << feature << '\n'
 437                        << "#endif" << '\n';
 438         }
 439     }
 440 }
 441
 442 void FeatureTreeModel::clear()
 443 {
 444     Feature::clear();
 445     sections.clear();
 446     parentMap.clear();
 447     featureIndexMap.clear();
 448     emit layoutChanged();
 449 }
 450
 451 QT_END_NAMESPACE