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: 2008-05-15 23:21:01 $
   7   Version:   $Revision: 1.28 $
   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 static QRegExp AdvancedRegExp[2] = { QRegExp("(false)"), QRegExp("(true|false)") };
  30
  31 // filter for searches
  32 class QCMakeSearchFilter : public QSortFilterProxyModel
  33 {
  34 public:
  35   QCMakeSearchFilter(QObject* o) : QSortFilterProxyModel(o) {}
  36 protected:
  37   bool filterAcceptsRow(int row, const QModelIndex& p) const
  38     {
  39     // accept row if either column matches
  40     QModelIndex idx0 = this->sourceModel()->index(row, 0, p);
  41     QModelIndex idx1 = this->sourceModel()->index(row, 1, p);
  42     QString str0 = this->sourceModel()->data(idx0).toString();
  43     QString str1 = this->sourceModel()->data(idx1).toString();
  44
  45     return str0.contains(this->filterRegExp()) ||
  46            str1.contains(this->filterRegExp());
  47     }
  48 };
  49
  50 QCMakeCacheView::QCMakeCacheView(QWidget* p)
  51   : QTableView(p), Init(false)
  52 {
  53   // hook up our model and search/filter proxies
  54   this->CacheModel = new QCMakeCacheModel(this);
  55   this->AdvancedFilter = new QSortFilterProxyModel(this);
  56   this->AdvancedFilter->setSourceModel(this->CacheModel);
  57   this->AdvancedFilter->setFilterRole(QCMakeCacheModel::AdvancedRole);
  58   this->AdvancedFilter->setFilterRegExp(AdvancedRegExp[0]);
  59   this->AdvancedFilter->setDynamicSortFilter(true);
  60   this->SearchFilter = new QCMakeSearchFilter(this);
  61   this->SearchFilter->setSourceModel(this->AdvancedFilter);
  62   this->SearchFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
  63   this->SearchFilter->setDynamicSortFilter(true);
  64   this->setModel(this->SearchFilter);
  65
  66   // our delegate for creating our editors
  67   QCMakeCacheModelDelegate* delegate = new QCMakeCacheModelDelegate(this);
  68   this->setItemDelegate(delegate);
  69
  70   this->setEditTriggers(QAbstractItemView::DoubleClicked |
  71                         QAbstractItemView::SelectedClicked |
  72                         QAbstractItemView::EditKeyPressed |
  73                         QAbstractItemView::AnyKeyPressed);
  74
  75   // tab, backtab doesn't step through items
  76   this->setTabKeyNavigation(false);
  77
  78   // set up headers and sizes
  79   int h = 0;
  80   QFontMetrics met(this->font());
  81   h = qMax(met.height(), this->style()->pixelMetric(QStyle::PM_IndicatorHeight));
  82   this->verticalHeader()->setDefaultSectionSize(h + 4);
  83   this->horizontalHeader()->setStretchLastSection(true);
  84   this->verticalHeader()->hide();
  85 }
  86
  87 void QCMakeCacheView::showEvent(QShowEvent* e)
  88 {
  89   if(!this->Init)
  90     {
  91     // initialize the table view column size
  92     int colWidth = this->columnWidth(0) + this->columnWidth(1);
  93     this->setColumnWidth(0, colWidth/2);
  94     this->setColumnWidth(1, colWidth/2);
  95     this->Init = true;
  96     }
  97   return QTableView::showEvent(e);
  98 }
  99
 100 QCMakeCacheModel* QCMakeCacheView::cacheModel() const
 101 {
 102   return this->CacheModel;
 103 }
 104
 105 QModelIndex QCMakeCacheView::moveCursor(CursorAction act,
 106   Qt::KeyboardModifiers mod)
 107 {
 108   // want home/end to go to begin/end of rows, not columns
 109   if(act == MoveHome)
 110     {
 111     return this->model()->index(0, 1);
 112     }
 113   else if(act == MoveEnd)
 114     {
 115     return this->model()->index(this->model()->rowCount()-1, 1);
 116     }
 117   return QTableView::moveCursor(act, mod);
 118 }
 119
 120 void QCMakeCacheView::setShowAdvanced(bool s)
 121 {
 122   this->AdvancedFilter->setFilterRegExp(
 123     s ? AdvancedRegExp[1] : AdvancedRegExp[0]);
 124 }
 125
 126 bool QCMakeCacheView::showAdvanced() const
 127 {
 128   return this->AdvancedFilter->filterRegExp() == AdvancedRegExp[1];
 129 }
 130
 131 void QCMakeCacheView::setSearchFilter(const QString& s)
 132 {
 133   this->SearchFilter->setFilterFixedString(s);
 134 }
 135
 136 QCMakeCacheModel::QCMakeCacheModel(QObject* p)
 137   : QAbstractTableModel(p),
 138     NewCount(0), EditEnabled(true)
 139 {
 140 }
 141
 142 QCMakeCacheModel::~QCMakeCacheModel()
 143 {
 144 }
 145
 146 static uint qHash(const QCMakeProperty& p)
 147 {
 148   return qHash(p.Key);
 149 }
 150
 151 void QCMakeCacheModel::clear()
 152 {
 153   this->setProperties(QCMakePropertyList());
 154 }
 155
 156 void QCMakeCacheModel::setProperties(const QCMakePropertyList& props)
 157 {
 158   QSet<QCMakeProperty> newProps = props.toSet();
 159   QSet<QCMakeProperty> newProps2 = props.toSet();
 160   QSet<QCMakeProperty> oldProps = this->Properties.toSet();
 161
 162   oldProps.intersect(newProps);
 163   newProps.subtract(oldProps);
 164   newProps2.subtract(newProps);
 165
 166   this->NewCount = newProps.count();
 167   this->Properties.clear();
 168
 169   this->Properties = newProps.toList();
 170   qSort(this->Properties);
 171   QCMakePropertyList tmp = newProps2.toList();
 172   qSort(tmp);
 173   this->Properties += tmp;
 174
 175   this->reset();
 176 }
 177
 178 QCMakePropertyList QCMakeCacheModel::properties() const
 179 {
 180   return this->Properties;
 181 }
 182
 183 bool QCMakeCacheModel::insertProperty(int row, QCMakeProperty::PropertyType t,
 184                       const QString& name, const QString& description,
 185                       const QVariant& value, bool advanced)
 186 {
 187   if(this->insertRows(row, 1, QModelIndex()))
 188     {
 189     QModelIndex idx1 = this->index(row, 0);
 190     QModelIndex idx2 = this->index(row, 1);
 191
 192     this->setData(idx1, t, QCMakeCacheModel::TypeRole);
 193     this->setData(idx1, name, Qt::DisplayRole);
 194     this->setData(idx1, description, QCMakeCacheModel::HelpRole);
 195     this->setData(idx1, advanced, QCMakeCacheModel::AdvancedRole);
 196     if(t == QCMakeProperty::BOOL)
 197       {
 198       this->setData(idx2, value.toBool() ? Qt::Checked : Qt::Unchecked,
 199         Qt::CheckStateRole);
 200       }
 201     else
 202       {
 203       this->setData(idx2, value, Qt::DisplayRole);
 204       }
 205     return true;
 206     }
 207   return false;
 208 }
 209
 210 void QCMakeCacheModel::setEditEnabled(bool e)
 211 {
 212   this->EditEnabled = e;
 213 }
 214
 215 bool QCMakeCacheModel::editEnabled() const
 216 {
 217   return this->EditEnabled;
 218 }
 219
 220 int QCMakeCacheModel::newCount() const
 221 {
 222   return this->NewCount;
 223 }
 224
 225 int QCMakeCacheModel::columnCount (const QModelIndex& /*p*/ ) const
 226 {
 227   return 2;
 228 }
 229
 230 QVariant QCMakeCacheModel::data (const QModelIndex& idx, int role) const
 231 {
 232   if(idx.column() == 0 && (role == Qt::DisplayRole || role == Qt::EditRole))
 233     {
 234     return this->Properties[idx.row()].Key;
 235     }
 236   else if(idx.column() == 0 && role == Qt::ToolTipRole)
 237     {
 238     return this->data(idx, Qt::DisplayRole).toString() + "\n" +
 239            this->data(idx, QCMakeCacheModel::HelpRole).toString();
 240     }
 241   else if(idx.column() == 1 && (role == Qt::DisplayRole || role == Qt::EditRole))
 242     {
 243     if(this->Properties[idx.row()].Type != QCMakeProperty::BOOL)
 244       {
 245       return this->Properties[idx.row()].Value;
 246       }
 247     }
 248   else if(idx.column() == 1 && role == Qt::CheckStateRole)
 249     {
 250     if(this->Properties[idx.row()].Type == QCMakeProperty::BOOL)
 251       {
 252       return this->Properties[idx.row()].Value.toBool() ? Qt::Checked : Qt::Unchecked;
 253       }
 254     }
 255   else if(role == QCMakeCacheModel::HelpRole)
 256     {
 257     return this->Properties[idx.row()].Help;
 258     }
 259   else if(role == QCMakeCacheModel::TypeRole)
 260     {
 261     return this->Properties[idx.row()].Type;
 262     }
 263   else if(role == QCMakeCacheModel::AdvancedRole)
 264     {
 265     return this->Properties[idx.row()].Advanced;
 266     }
 267   else if(role == Qt::BackgroundRole && idx.row()+1 <= this->NewCount)
 268     {
 269     return QBrush(QColor(255,100,100));
 270     }
 271   return QVariant();
 272 }
 273
 274 QModelIndex QCMakeCacheModel::parent (const QModelIndex& /*idx*/) const
 275 {
 276   return QModelIndex();
 277 }
 278
 279 int QCMakeCacheModel::rowCount (const QModelIndex& p) const
 280 {
 281   if(p.isValid())
 282     {
 283     return 0;
 284     }
 285   return this->Properties.count();
 286 }
 287
 288 QVariant QCMakeCacheModel::headerData (int section, Qt::Orientation orient, int role) const
 289 {
 290   // return header labels
 291   if(role == Qt::DisplayRole && orient == Qt::Horizontal)
 292     {
 293     return section == 0 ? "Name" : "Value";
 294     }
 295   return QVariant();
 296 }
 297
 298 Qt::ItemFlags QCMakeCacheModel::flags (const QModelIndex& idx) const
 299 {
 300   Qt::ItemFlags f = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 301   // all column 1's are editable
 302   if(idx.column() == 1 && this->EditEnabled)
 303     {
 304     f |= Qt::ItemIsEditable;
 305     // booleans are editable in place
 306     if(this->Properties[idx.row()].Type == QCMakeProperty::BOOL)
 307       {
 308       f |= Qt::ItemIsUserCheckable;
 309       }
 310     }
 311   return f;
 312 }
 313
 314
 315 bool QCMakeCacheModel::setData (const QModelIndex& idx, const QVariant& value, int role)
 316 {
 317   if(idx.column() == 0 && (role == Qt::DisplayRole || role == Qt::EditRole))
 318     {
 319     this->Properties[idx.row()].Key = value.toString();
 320     emit this->dataChanged(idx, idx);
 321     }
 322   else if(idx.column() == 1 && (role == Qt::DisplayRole || role == Qt::EditRole))
 323     {
 324     this->Properties[idx.row()].Value = value.toString();
 325     emit this->dataChanged(idx, idx);
 326     }
 327   else if(idx.column() == 1 && (role == Qt::CheckStateRole))
 328     {
 329     this->Properties[idx.row()].Value = value.toInt() == Qt::Checked;
 330     emit this->dataChanged(idx, idx);
 331     }
 332   else if(role == QCMakeCacheModel::HelpRole)
 333     {
 334     this->Properties[idx.row()].Help = value.toString();
 335     emit this->dataChanged(idx, idx);
 336     }
 337   else if(role == QCMakeCacheModel::TypeRole)
 338     {
 339     this->Properties[idx.row()].Type = static_cast<QCMakeProperty::PropertyType>(value.toInt());
 340     }
 341   else if(role == QCMakeCacheModel::AdvancedRole)
 342     {
 343     this->Properties[idx.row()].Advanced = value.toBool();
 344     }
 345   return false;
 346 }
 347
 348 QModelIndex QCMakeCacheModel::buddy(const QModelIndex& idx) const
 349 {
 350   if(idx.column() == 0)
 351     {
 352     if(this->Properties[idx.row()].Type != QCMakeProperty::BOOL)
 353       {
 354       return this->index(idx.row(), 1);
 355       }
 356     }
 357   return idx;
 358 }
 359
 360 bool QCMakeCacheModel::removeRows(int row, int num, const QModelIndex&)
 361 {
 362   if(row < 0 || row+num > this->Properties.count())
 363     {
 364     return false;
 365     }
 366   this->beginRemoveRows(QModelIndex(), row, row+num-1);
 367   for(int i=0; i<num; i++)
 368     {
 369     this->Properties.removeAt(row);
 370     if(this->NewCount >= row+1)
 371       {
 372       this->NewCount--;
 373       }
 374     }
 375   this->endRemoveRows();
 376   return true;
 377 }
 378
 379 bool QCMakeCacheModel::insertRows(int row, int num, const QModelIndex&)
 380 {
 381   if(row < 0)
 382     row = 0;
 383   if(row > this->rowCount())
 384     row = this->rowCount();
 385
 386   this->beginInsertRows(QModelIndex(), row, row+num-1);
 387   for(int i=0; i<num; i++)
 388     {
 389     this->Properties.insert(row+i, QCMakeProperty());
 390     if(this->NewCount >= row)
 391       {
 392       this->NewCount++;
 393       }
 394     }
 395   this->endInsertRows();
 396   return true;
 397 }
 398
 399 QCMakeCacheModelDelegate::QCMakeCacheModelDelegate(QObject* p)
 400   : QItemDelegate(p), FileDialogFlag(false)
 401 {
 402 }
 403
 404 void QCMakeCacheModelDelegate::setFileDialogFlag(bool f)
 405 {
 406   this->FileDialogFlag = f;
 407 }
 408
 409 QWidget* QCMakeCacheModelDelegate::createEditor(QWidget* p,
 410     const QStyleOptionViewItem&, const QModelIndex& idx) const
 411 {
 412   const QAbstractItemModel* model = idx.model();
 413   QModelIndex var = model->index(idx.row(), 0);
 414   QVariant type = idx.data(QCMakeCacheModel::TypeRole);
 415   if(type == QCMakeProperty::BOOL)
 416     {
 417     return NULL;
 418     }
 419   else if(type == QCMakeProperty::PATH)
 420     {
 421     QCMakePathEditor* editor =
 422       new QCMakePathEditor(p,
 423       var.data(Qt::DisplayRole).toString());
 424     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 425         SLOT(setFileDialogFlag(bool)));
 426     return editor;
 427     }
 428   else if(type == QCMakeProperty::FILEPATH)
 429     {
 430     QCMakeFilePathEditor* editor =
 431       new QCMakeFilePathEditor(p,
 432       var.data(Qt::DisplayRole).toString());
 433     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 434         SLOT(setFileDialogFlag(bool)));
 435     return editor;
 436     }
 437
 438   return new QLineEdit(p);
 439 }
 440
 441 bool QCMakeCacheModelDelegate::editorEvent(QEvent* e, QAbstractItemModel* model,
 442        const QStyleOptionViewItem& option, const QModelIndex& index)
 443 {
 444   Qt::ItemFlags flags = model->flags(index);
 445   if (!(flags & Qt::ItemIsUserCheckable) || !(option.state & QStyle::State_Enabled)
 446       || !(flags & Qt::ItemIsEnabled))
 447     {
 448     return false;
 449     }
 450
 451   QVariant value = index.data(Qt::CheckStateRole);
 452   if (!value.isValid())
 453     {
 454     return false;
 455     }
 456
 457   if ((e->type() == QEvent::MouseButtonRelease)
 458       || (e->type() == QEvent::MouseButtonDblClick))
 459     {
 460     // eat the double click events inside the check rect
 461     if (e->type() == QEvent::MouseButtonDblClick)
 462       {
 463       return true;
 464       }
 465     }
 466   else if (e->type() == QEvent::KeyPress)
 467     {
 468     if(static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
 469        static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select)
 470       {
 471       return false;
 472       }
 473     }
 474   else
 475     {
 476     return false;
 477     }
 478
 479   Qt::CheckState state = (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked
 480                           ? Qt::Unchecked : Qt::Checked);
 481   return model->setData(index, state, Qt::CheckStateRole);
 482 }
 483
 484 bool QCMakeCacheModelDelegate::eventFilter(QObject* object, QEvent* event)
 485 {
 486   // workaround for what looks like a bug in Qt on Mac OS X
 487   if(event->type() == QEvent::FocusOut && this->FileDialogFlag)
 488   {
 489     return false;
 490   }
 491   return QItemDelegate::eventFilter(object, event);
 492 }
 493
 494