Source/QtDialog/QCMakeCacheView.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: QCMakeCacheView.cxx,v $
   5   Language:  C++
   6   Date:      $Date: 2009-03-26 15:42:37 $
   7   Version:   $Revision: 1.40 $
   8
   9   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  10   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  11
  12      This software is distributed WITHOUT ANY WARRANTY; without even
  13      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  14      PURPOSE.  See the above copyright notices for more information.
  15
  16 =========================================================================*/
  17
  18 #include "QCMakeCacheView.h"
  19
  20 #include <QHBoxLayout>
  21 #include <QHeaderView>
  22 #include <QEvent>
  23 #include <QStyle>
  24 #include <QKeyEvent>
  25 #include <QSortFilterProxyModel>
  26
  27 #include "QCMakeWidgets.h"
  28
  29 // filter for searches
  30 class QCMakeSearchFilter : public QSortFilterProxyModel
  31 {
  32 public:
  33   QCMakeSearchFilter(QObject* o) : QSortFilterProxyModel(o) {}
  34 protected:
  35   bool filterAcceptsRow(int row, const QModelIndex& p) const
  36     {
  37     QStringList strs;
  38     const QAbstractItemModel* m = this->sourceModel();
  39     QModelIndex idx = m->index(row, 0, p);
  40
  41     // if there are no children, get strings for column 0 and 1
  42     if(!m->hasChildren(idx))
  43       {
  44       strs.append(m->data(idx).toString());
  45       idx = m->index(row, 1, p);
  46       strs.append(m->data(idx).toString());
  47       }
  48     else
  49       {
  50       // get strings for children entries to compare with
  51       // instead of comparing with the parent
  52       int num = m->rowCount(idx);
  53       for(int i=0; i<num; i++)
  54         {
  55         QModelIndex tmpidx = m->index(i, 0, idx);
  56         strs.append(m->data(tmpidx).toString());
  57         tmpidx = m->index(i, 1, idx);
  58         strs.append(m->data(tmpidx).toString());
  59         }
  60       }
  61
  62     // check all strings for a match
  63     foreach(QString str, strs)
  64       {
  65       if(str.contains(this->filterRegExp()))
  66         {
  67         return true;
  68         }
  69       }
  70
  71     return false;
  72     }
  73 };
  74
  75 // filter for searches
  76 class QCMakeAdvancedFilter : public QSortFilterProxyModel
  77 {
  78 public:
  79   QCMakeAdvancedFilter(QObject* o)
  80     : QSortFilterProxyModel(o), ShowAdvanced(false) {}
  81
  82   void setShowAdvanced(bool f)
  83   {
  84     this->ShowAdvanced = f;
  85     this->invalidate();
  86   }
  87   bool showAdvanced() const { return this->ShowAdvanced; }
  88
  89 protected:
  90
  91   bool ShowAdvanced;
  92
  93   bool filterAcceptsRow(int row, const QModelIndex& p) const
  94     {
  95     const QAbstractItemModel* m = this->sourceModel();
  96     QModelIndex idx = m->index(row, 0, p);
  97
  98     // if there are no children
  99     if(!m->hasChildren(idx))
 100       {
 101       bool adv = m->data(idx, QCMakeCacheModel::AdvancedRole).toBool();
 102       if(!adv || (adv && this->ShowAdvanced))
 103         {
 104         return true;
 105         }
 106       return false;
 107       }
 108
 109     // check children
 110     int num = m->rowCount(idx);
 111     for(int i=0; i<num; i++)
 112       {
 113       bool accept = this->filterAcceptsRow(i, idx);
 114       if(accept)
 115         {
 116         return true;
 117         }
 118       }
 119     return false;
 120     }
 121 };
 122
 123 QCMakeCacheView::QCMakeCacheView(QWidget* p)
 124   : QTreeView(p)
 125 {
 126   // hook up our model and search/filter proxies
 127   this->CacheModel = new QCMakeCacheModel(this);
 128   this->AdvancedFilter = new QCMakeAdvancedFilter(this);
 129   this->AdvancedFilter->setSourceModel(this->CacheModel);
 130   this->AdvancedFilter->setDynamicSortFilter(true);
 131   this->SearchFilter = new QCMakeSearchFilter(this);
 132   this->SearchFilter->setSourceModel(this->AdvancedFilter);
 133   this->SearchFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
 134   this->SearchFilter->setDynamicSortFilter(true);
 135   this->setModel(this->SearchFilter);
 136
 137   // our delegate for creating our editors
 138   QCMakeCacheModelDelegate* delegate = new QCMakeCacheModelDelegate(this);
 139   this->setItemDelegate(delegate);
 140
 141   this->setEditTriggers(QAbstractItemView::DoubleClicked |
 142                         QAbstractItemView::SelectedClicked |
 143                         QAbstractItemView::EditKeyPressed |
 144                         QAbstractItemView::AnyKeyPressed);
 145
 146   // tab, backtab doesn't step through items
 147   this->setTabKeyNavigation(false);
 148
 149   this->setRootIsDecorated(false);
 150 }
 151
 152 bool QCMakeCacheView::event(QEvent* e)
 153 {
 154   if(e->type() == QEvent::Show)
 155     {
 156     this->header()->setDefaultSectionSize(this->viewport()->width()/2);
 157     }
 158   return QTreeView::event(e);
 159 }
 160
 161 QCMakeCacheModel* QCMakeCacheView::cacheModel() const
 162 {
 163   return this->CacheModel;
 164 }
 165
 166 QModelIndex QCMakeCacheView::moveCursor(CursorAction act,
 167   Qt::KeyboardModifiers mod)
 168 {
 169   // want home/end to go to begin/end of rows, not columns
 170   if(act == MoveHome)
 171     {
 172     return this->model()->index(0, 1);
 173     }
 174   else if(act == MoveEnd)
 175     {
 176     return this->model()->index(this->model()->rowCount()-1, 1);
 177     }
 178   return QTreeView::moveCursor(act, mod);
 179 }
 180
 181 void QCMakeCacheView::setShowAdvanced(bool s)
 182 {
 183 #if QT_VERSION >= 040300
 184   // new 4.3 api that needs to be called.  what about an older Qt?
 185   this->SearchFilter->invalidate();
 186 #endif
 187
 188   this->AdvancedFilter->setShowAdvanced(s);
 189 }
 190
 191 bool QCMakeCacheView::showAdvanced() const
 192 {
 193   return this->AdvancedFilter->showAdvanced();
 194 }
 195
 196 void QCMakeCacheView::setSearchFilter(const QString& s)
 197 {
 198   this->SearchFilter->setFilterFixedString(s);
 199 }
 200
 201 QCMakeCacheModel::QCMakeCacheModel(QObject* p)
 202   : QStandardItemModel(p),
 203     EditEnabled(true),
 204     NewPropertyCount(0),
 205     View(FlatView)
 206 {
 207   QStringList labels;
 208   labels << tr("Name") << tr("Value");
 209   this->setHorizontalHeaderLabels(labels);
 210 }
 211
 212 QCMakeCacheModel::~QCMakeCacheModel()
 213 {
 214 }
 215
 216 static uint qHash(const QCMakeProperty& p)
 217 {
 218   return qHash(p.Key);
 219 }
 220
 221 void QCMakeCacheModel::clear()
 222 {
 223   this->QStandardItemModel::clear();
 224   this->NewPropertyCount = 0;
 225
 226   QStringList labels;
 227   labels << tr("Name") << tr("Value");
 228   this->setHorizontalHeaderLabels(labels);
 229 }
 230
 231 void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
 232 {
 233   QSet<QCMakeProperty> newProps = props.toSet();
 234   QSet<QCMakeProperty> newProps2 = newProps;
 235   QSet<QCMakeProperty> oldProps = this->properties().toSet();
 236
 237   oldProps.intersect(newProps);
 238   newProps.subtract(oldProps);
 239   newProps2.subtract(newProps);
 240
 241   bool b = this->blockSignals(true);
 242
 243   this->clear();
 244   this->NewPropertyCount = newProps.size();
 245
 246   if(View == FlatView)
 247   {
 248     QCMakePropertyList newP = newProps.toList();
 249     QCMakePropertyList newP2 = newProps2.toList();
 250     qSort(newP);
 251     qSort(newP2);
 252     int rowCount = 0;
 253     foreach(QCMakeProperty p, newP)
 254     {
 255       this->insertRow(rowCount);
 256       this->setPropertyData(this->index(rowCount, 0), p, true);
 257       rowCount++;
 258     }
 259     foreach(QCMakeProperty p, newP2)
 260     {
 261       this->insertRow(rowCount);
 262       this->setPropertyData(this->index(rowCount, 0), p, false);
 263       rowCount++;
 264     }
 265   }
 266   else if(this->View == GroupView)
 267   {
 268     QMap<QString, QCMakePropertyList> newPropsTree;
 269     this->breakProperties(newProps, newPropsTree);
 270     QMap<QString, QCMakePropertyList> newPropsTree2;
 271     this->breakProperties(newProps2, newPropsTree2);
 272
 273     QStandardItem* root = this->invisibleRootItem();
 274
 275     foreach(QString key, newPropsTree.keys())
 276       {
 277       QCMakePropertyList props = newPropsTree[key];
 278
 279       QList<QStandardItem*> parentItems;
 280       parentItems.append(
 281         new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key)
 282         );
 283       parentItems.append(new QStandardItem());
 284       parentItems[0]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
 285       parentItems[1]->setData(QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
 286       root->appendRow(parentItems);
 287
 288       foreach(QCMakeProperty prop, props)
 289         {
 290         QList<QStandardItem*> items;
 291         items.append(new QStandardItem());
 292         items.append(new QStandardItem());
 293         parentItems[0]->appendRow(items);
 294         this->setPropertyData(this->indexFromItem(items[0]), prop, true);
 295         }
 296       }
 297
 298     foreach(QString key, newPropsTree2.keys())
 299       {
 300       QCMakePropertyList props = newPropsTree2[key];
 301
 302       QStandardItem* parentItem =
 303         new QStandardItem(key.isEmpty() ? tr("Ungrouped Entries") : key);
 304       root->appendRow(parentItem);
 305
 306       foreach(QCMakeProperty prop, props)
 307         {
 308         QList<QStandardItem*> items;
 309         items.append(new QStandardItem());
 310         items.append(new QStandardItem());
 311         parentItem->appendRow(items);
 312         this->setPropertyData(this->indexFromItem(items[0]), prop, false);
 313         }
 314       }
 315   }
 316
 317   this->blockSignals(b);
 318   this->reset();
 319 }
 320
 321 QCMakeCacheModel::ViewType QCMakeCacheModel::viewType() const
 322 {
 323   return this->View;
 324 }
 325
 326 void QCMakeCacheModel::setViewType(QCMakeCacheModel::ViewType t)
 327 {
 328   this->View = t;
 329
 330   QCMakePropertyList props = this->properties();
 331   QCMakePropertyList oldProps;
 332   int numNew = this->NewPropertyCount;
 333   int numTotal = props.count();
 334   for(int i=numNew; i<numTotal; i++)
 335   {
 336     oldProps.append(props[i]);
 337   }
 338
 339   bool b = this->blockSignals(true);
 340   this->clear();
 341   this->setProperties(oldProps);
 342   this->setProperties(props);
 343   this->blockSignals(b);
 344   this->reset();
 345 }
 346
 347 void QCMakeCacheModel::setPropertyData(const QModelIndex& idx1,
 348     const QCMakeProperty& prop, bool isNew)
 349 {
 350   QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
 351
 352   this->setData(idx1, prop.Key, Qt::DisplayRole);
 353   this->setData(idx1, prop.Help, QCMakeCacheModel::HelpRole);
 354   this->setData(idx1, prop.Type, QCMakeCacheModel::TypeRole);
 355   this->setData(idx1, prop.Advanced, QCMakeCacheModel::AdvancedRole);
 356
 357   if(prop.Type == QCMakeProperty::BOOL)
 358   {
 359     int check = prop.Value.toBool() ? Qt::Checked : Qt::Unchecked;
 360     this->setData(idx2, check, Qt::CheckStateRole);
 361   }
 362   else
 363   {
 364     this->setData(idx2, prop.Value, Qt::DisplayRole);
 365   }
 366   this->setData(idx2, prop.Help, QCMakeCacheModel::HelpRole);
 367
 368   if (!prop.Strings.isEmpty())
 369   {
 370     this->setData(idx1, prop.Strings, QCMakeCacheModel::StringsRole);
 371   }
 372
 373   if(isNew)
 374   {
 375     this->setData(idx1, QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
 376     this->setData(idx2, QBrush(QColor(255,100,100)), Qt::BackgroundColorRole);
 377   }
 378 }
 379
 380 void QCMakeCacheModel::getPropertyData(const QModelIndex& idx1,
 381     QCMakeProperty& prop) const
 382 {
 383   QModelIndex idx2 = idx1.sibling(idx1.row(), 1);
 384
 385   prop.Key = this->data(idx1, Qt::DisplayRole).toString();
 386   prop.Help = this->data(idx1, HelpRole).toString();
 387   prop.Type = static_cast<QCMakeProperty::PropertyType>(this->data(idx1, TypeRole).toInt());
 388   prop.Advanced = this->data(idx1, AdvancedRole).toBool();
 389   prop.Strings = this->data(idx1, QCMakeCacheModel::StringsRole).toStringList();
 390   if(prop.Type == QCMakeProperty::BOOL)
 391   {
 392     int check = this->data(idx2, Qt::CheckStateRole).toInt();
 393     prop.Value = check == Qt::Checked;
 394   }
 395   else
 396   {
 397     prop.Value = this->data(idx2, Qt::DisplayRole).toString();
 398   }
 399 }
 400
 401 QString QCMakeCacheModel::prefix(const QString& s)
 402 {
 403   QString prefix = s.section('_', 0, 0);
 404   if(prefix == s)
 405     {
 406     prefix = QString();
 407     }
 408   return prefix;
 409 }
 410
 411 void QCMakeCacheModel::breakProperties(const QSet<QCMakeProperty>& props,
 412                      QMap<QString, QCMakePropertyList>& result)
 413 {
 414   QMap<QString, QCMakePropertyList> tmp;
 415   // return a map of properties grouped by prefixes, and sorted
 416   foreach(QCMakeProperty p, props)
 417     {
 418     QString prefix = QCMakeCacheModel::prefix(p.Key);
 419     tmp[prefix].append(p);
 420     }
 421   // sort it and re-org any properties with only one sub item
 422   QCMakePropertyList reorgProps;
 423   QMap<QString, QCMakePropertyList>::iterator iter;
 424   for(iter = tmp.begin(); iter != tmp.end();)
 425     {
 426     if(iter->count() == 1)
 427       {
 428       reorgProps.append((*iter)[0]);
 429       iter = tmp.erase(iter);
 430       }
 431     else
 432       {
 433       qSort(*iter);
 434       ++iter;
 435       }
 436     }
 437   if(reorgProps.count())
 438     {
 439     tmp[QString()] += reorgProps;
 440     }
 441   result = tmp;
 442 }
 443
 444 QCMakePropertyList QCMakeCacheModel::properties() const
 445 {
 446   QCMakePropertyList props;
 447
 448   if(!this->rowCount())
 449     {
 450     return props;
 451     }
 452
 453   QList<QModelIndex> idxs;
 454   idxs.append(this->index(0,0));
 455
 456   // walk the entire model for property entries
 457   // this works regardless of a flat view or a tree view
 458   while(!idxs.isEmpty())
 459   {
 460     QModelIndex idx = idxs.last();
 461     if(this->hasChildren(idx) && this->rowCount(idx))
 462     {
 463       idxs.append(this->index(0,0, idx));
 464     }
 465     else
 466     {
 467       // get data
 468       QCMakeProperty prop;
 469       this->getPropertyData(idx, prop);
 470       props.append(prop);
 471
 472       // go to the next in the tree
 473       while(!idxs.isEmpty() && !idxs.last().sibling(idxs.last().row()+1, 0).isValid())
 474       {
 475         idxs.removeLast();
 476       }
 477       if(!idxs.isEmpty())
 478       {
 479         idxs.last() = idxs.last().sibling(idxs.last().row()+1, 0);
 480       }
 481     }
 482   }
 483
 484   return props;
 485 }
 486
 487 bool QCMakeCacheModel::insertProperty(QCMakeProperty::PropertyType t,
 488                       const QString& name, const QString& description,
 489                       const QVariant& value, bool advanced)
 490 {
 491   QCMakeProperty prop;
 492   prop.Key = name;
 493   prop.Value = value;
 494   prop.Help = description;
 495   prop.Type = t;
 496   prop.Advanced = advanced;
 497
 498   //insert at beginning
 499   this->insertRow(0);
 500   this->setPropertyData(this->index(0,0), prop, true);
 501   this->NewPropertyCount++;
 502   return true;
 503 }
 504
 505 void QCMakeCacheModel::setEditEnabled(bool e)
 506 {
 507   this->EditEnabled = e;
 508 }
 509
 510 bool QCMakeCacheModel::editEnabled() const
 511 {
 512   return this->EditEnabled;
 513 }
 514
 515 int QCMakeCacheModel::newPropertyCount() const
 516 {
 517   return this->NewPropertyCount;
 518 }
 519
 520 Qt::ItemFlags QCMakeCacheModel::flags (const QModelIndex& idx) const
 521 {
 522   Qt::ItemFlags f = QStandardItemModel::flags(idx);
 523   if(!this->EditEnabled)
 524     {
 525     f &= ~Qt::ItemIsEditable;
 526     return f;
 527     }
 528   if(QCMakeProperty::BOOL == this->data(idx, TypeRole).toInt())
 529     {
 530     f |= Qt::ItemIsUserCheckable;
 531     }
 532   return f;
 533 }
 534
 535 QModelIndex QCMakeCacheModel::buddy(const QModelIndex& idx) const
 536 {
 537   if(!this->hasChildren(idx) &&
 538      this->data(idx, TypeRole).toInt() != QCMakeProperty::BOOL)
 539   {
 540     return this->index(idx.row(), 1, idx.parent());
 541   }
 542   return idx;
 543 }
 544
 545 QCMakeCacheModelDelegate::QCMakeCacheModelDelegate(QObject* p)
 546   : QItemDelegate(p), FileDialogFlag(false)
 547 {
 548 }
 549
 550 void QCMakeCacheModelDelegate::setFileDialogFlag(bool f)
 551 {
 552   this->FileDialogFlag = f;
 553 }
 554
 555 QWidget* QCMakeCacheModelDelegate::createEditor(QWidget* p,
 556     const QStyleOptionViewItem&, const QModelIndex& idx) const
 557 {
 558   QModelIndex var = idx.sibling(idx.row(), 0);
 559   int type = var.data(QCMakeCacheModel::TypeRole).toInt();
 560   if(type == QCMakeProperty::BOOL)
 561     {
 562     return NULL;
 563     }
 564   else if(type == QCMakeProperty::PATH)
 565     {
 566     QCMakePathEditor* editor =
 567       new QCMakePathEditor(p,
 568       var.data(Qt::DisplayRole).toString());
 569     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 570         SLOT(setFileDialogFlag(bool)));
 571     return editor;
 572     }
 573   else if(type == QCMakeProperty::FILEPATH)
 574     {
 575     QCMakeFilePathEditor* editor =
 576       new QCMakeFilePathEditor(p,
 577       var.data(Qt::DisplayRole).toString());
 578     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 579         SLOT(setFileDialogFlag(bool)));
 580     return editor;
 581     }
 582   else if(type == QCMakeProperty::STRING &&
 583           var.data(QCMakeCacheModel::StringsRole).isValid())
 584     {
 585     QCMakeComboBox* editor =
 586       new QCMakeComboBox(p, var.data(QCMakeCacheModel::StringsRole).toStringList());
 587     editor->setFrame(false);
 588     return editor;
 589     }
 590
 591   QLineEdit* editor = new QLineEdit(p);
 592   editor->setFrame(false);
 593   return editor;
 594 }
 595
 596 bool QCMakeCacheModelDelegate::editorEvent(QEvent* e, QAbstractItemModel* model,
 597        const QStyleOptionViewItem& option, const QModelIndex& index)
 598 {
 599   Qt::ItemFlags flags = model->flags(index);
 600   if (!(flags & Qt::ItemIsUserCheckable) || !(option.state & QStyle::State_Enabled)
 601       || !(flags & Qt::ItemIsEnabled))
 602     {
 603     return false;
 604     }
 605
 606   QVariant value = index.data(Qt::CheckStateRole);
 607   if (!value.isValid())
 608     {
 609     return false;
 610     }
 611
 612   if ((e->type() == QEvent::MouseButtonRelease)
 613       || (e->type() == QEvent::MouseButtonDblClick))
 614     {
 615     // eat the double click events inside the check rect
 616     if (e->type() == QEvent::MouseButtonDblClick)
 617       {
 618       return true;
 619       }
 620     }
 621   else if (e->type() == QEvent::KeyPress)
 622     {
 623     if(static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
 624        static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select)
 625       {
 626       return false;
 627       }
 628     }
 629   else
 630     {
 631     return false;
 632     }
 633
 634   Qt::CheckState state = (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked
 635                           ? Qt::Unchecked : Qt::Checked);
 636   return model->setData(index, state, Qt::CheckStateRole);
 637 }
 638
 639 bool QCMakeCacheModelDelegate::eventFilter(QObject* object, QEvent* event)
 640 {
 641   // workaround for what looks like a bug in Qt on Mac OS X
 642   // where it doesn't create a QWidget wrapper for the native file dialog
 643   // so the Qt library ends up assuming the focus was lost to something else
 644   if(event->type() == QEvent::FocusOut && this->FileDialogFlag)
 645     {
 646     return false;
 647     }
 648   return QItemDelegate::eventFilter(object, event);
 649 }
 650
 651