CMakeLua/Source/QtDialog/QCMakeCacheView.cxx

   1 /*=========================================================================
   2
   3   Program:   CMake - Cross-Platform Makefile Generator
   4   Module:    $RCSfile: QCMakeCacheView.cxx,v $
   5   Language:  C++
   6 <<<<<<< QCMakeCacheView.cxx
   7   Date:      $Date: 2008/02/15 00:58:31 $
   8   Version:   $Revision: 1.26 $
   9 =======
  10   Date:      $Date: 2008-04-02 19:28:17 $
  11   Version:   $Revision: 1.27 $
  12 >>>>>>> 1.27
  13
  14   Copyright (c) 2002 Kitware, Inc., Insight Consortium.  All rights reserved.
  15   See Copyright.txt or http://www.cmake.org/HTML/Copyright.html for details.
  16
  17      This software is distributed WITHOUT ANY WARRANTY; without even
  18      the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
  19      PURPOSE.  See the above copyright notices for more information.
  20
  21 =========================================================================*/
  22
  23 #include "QCMakeCacheView.h"
  24
  25 #include <QToolButton>
  26 #include <QFileDialog>
  27 #include <QHBoxLayout>
  28 #include <QHeaderView>
  29 #include <QEvent>
  30 #include <QFileInfo>
  31 #include <QStyle>
  32 #include <QKeyEvent>
  33 #include <QMenu>
  34 #include <QDirModel>
  35
  36 static QRegExp AdvancedRegExp[2] = { QRegExp("(false)"), QRegExp("(true|false)") };
  37
  38 // filter for searches
  39 class QCMakeSearchFilter : public QSortFilterProxyModel
  40 {
  41 public:
  42   QCMakeSearchFilter(QObject* o) : QSortFilterProxyModel(o) {}
  43 protected:
  44   bool filterAcceptsRow(int row, const QModelIndex& p) const
  45     {
  46     // accept row if either column matches
  47     QModelIndex idx0 = this->sourceModel()->index(row, 0, p);
  48     QModelIndex idx1 = this->sourceModel()->index(row, 1, p);
  49     QString str0 = this->sourceModel()->data(idx0).toString();
  50     QString str1 = this->sourceModel()->data(idx1).toString();
  51
  52     return str0.contains(this->filterRegExp()) ||
  53            str1.contains(this->filterRegExp());
  54     }
  55 };
  56
  57 QCMakeCacheView::QCMakeCacheView(QWidget* p)
  58   : QTableView(p), Init(false)
  59 {
  60   // hook up our model and search/filter proxies
  61   this->CacheModel = new QCMakeCacheModel(this);
  62   this->AdvancedFilter = new QSortFilterProxyModel(this);
  63   this->AdvancedFilter->setSourceModel(this->CacheModel);
  64   this->AdvancedFilter->setFilterRole(QCMakeCacheModel::AdvancedRole);
  65   this->AdvancedFilter->setFilterRegExp(AdvancedRegExp[0]);
  66   this->AdvancedFilter->setDynamicSortFilter(true);
  67   this->SearchFilter = new QCMakeSearchFilter(this);
  68   this->SearchFilter->setSourceModel(this->AdvancedFilter);
  69   this->SearchFilter->setFilterCaseSensitivity(Qt::CaseInsensitive);
  70   this->SearchFilter->setDynamicSortFilter(true);
  71   this->setModel(this->SearchFilter);
  72
  73   // our delegate for creating our editors
  74   QCMakeCacheModelDelegate* delegate = new QCMakeCacheModelDelegate(this);
  75   this->setItemDelegate(delegate);
  76
  77   this->setEditTriggers(QAbstractItemView::DoubleClicked |
  78                         QAbstractItemView::SelectedClicked |
  79                         QAbstractItemView::EditKeyPressed |
  80                         QAbstractItemView::AnyKeyPressed);
  81
  82   // tab, backtab doesn't step through items
  83   this->setTabKeyNavigation(false);
  84
  85   // set up headers and sizes
  86   int h = 0;
  87   QFontMetrics met(this->font());
  88   h = qMax(met.height(), this->style()->pixelMetric(QStyle::PM_IndicatorHeight));
  89   this->verticalHeader()->setDefaultSectionSize(h + 4);
  90   this->horizontalHeader()->setStretchLastSection(true);
  91   this->verticalHeader()->hide();
  92 }
  93
  94 void QCMakeCacheView::showEvent(QShowEvent* e)
  95 {
  96   if(!this->Init)
  97     {
  98     // initialize the table view column size
  99     int colWidth = this->columnWidth(0) + this->columnWidth(1);
 100     this->setColumnWidth(0, colWidth/2);
 101     this->setColumnWidth(1, colWidth/2);
 102     this->Init = true;
 103     }
 104   return QTableView::showEvent(e);
 105 }
 106
 107 QCMakeCacheModel* QCMakeCacheView::cacheModel() const
 108 {
 109   return this->CacheModel;
 110 }
 111
 112 QModelIndex QCMakeCacheView::moveCursor(CursorAction act,
 113   Qt::KeyboardModifiers mod)
 114 {
 115   // want home/end to go to begin/end of rows, not columns
 116   if(act == MoveHome)
 117     {
 118     return this->model()->index(0, 1);
 119     }
 120   else if(act == MoveEnd)
 121     {
 122     return this->model()->index(this->model()->rowCount()-1, 1);
 123     }
 124   return QTableView::moveCursor(act, mod);
 125 }
 126
 127 void QCMakeCacheView::setShowAdvanced(bool s)
 128 {
 129   this->AdvancedFilter->setFilterRegExp(
 130     s ? AdvancedRegExp[1] : AdvancedRegExp[0]);
 131 }
 132
 133 bool QCMakeCacheView::showAdvanced() const
 134 {
 135   return this->AdvancedFilter->filterRegExp() == AdvancedRegExp[1];
 136 }
 137
 138 void QCMakeCacheView::setSearchFilter(const QString& s)
 139 {
 140   this->SearchFilter->setFilterFixedString(s);
 141 }
 142
 143 QCMakeCacheModel::QCMakeCacheModel(QObject* p)
 144   : QAbstractTableModel(p),
 145     NewCount(0), EditEnabled(true)
 146 {
 147 }
 148
 149 QCMakeCacheModel::~QCMakeCacheModel()
 150 {
 151 }
 152
 153 static uint qHash(const QCMakeCacheProperty& p)
 154 {
 155   return qHash(p.Key);
 156 }
 157
 158 void QCMakeCacheModel::clear()
 159 {
 160   this->setProperties(QCMakeCachePropertyList());
 161 }
 162
 163 void QCMakeCacheModel::setProperties(const QCMakeCachePropertyList& props)
 164 {
 165   QSet<QCMakeCacheProperty> newProps = props.toSet();
 166   QSet<QCMakeCacheProperty> newProps2 = props.toSet();
 167   QSet<QCMakeCacheProperty> oldProps = this->Properties.toSet();
 168
 169   oldProps.intersect(newProps);
 170   newProps.subtract(oldProps);
 171   newProps2.subtract(newProps);
 172
 173   this->NewCount = newProps.count();
 174   this->Properties.clear();
 175
 176   this->Properties = newProps.toList();
 177   qSort(this->Properties);
 178   QCMakeCachePropertyList tmp = newProps2.toList();
 179   qSort(tmp);
 180   this->Properties += tmp;
 181
 182   this->reset();
 183 }
 184
 185 QCMakeCachePropertyList QCMakeCacheModel::properties() const
 186 {
 187   return this->Properties;
 188 }
 189
 190 void QCMakeCacheModel::setEditEnabled(bool e)
 191 {
 192   this->EditEnabled = e;
 193 }
 194
 195 bool QCMakeCacheModel::editEnabled() const
 196 {
 197   return this->EditEnabled;
 198 }
 199
 200 int QCMakeCacheModel::newCount() const
 201 {
 202   return this->NewCount;
 203 }
 204
 205 int QCMakeCacheModel::columnCount (const QModelIndex& /*p*/ ) const
 206 {
 207   return 2;
 208 }
 209
 210 QVariant QCMakeCacheModel::data (const QModelIndex& idx, int role) const
 211 {
 212   if(idx.column() == 0 && (role == Qt::DisplayRole || role == Qt::EditRole))
 213     {
 214     return this->Properties[idx.row()].Key;
 215     }
 216   else if(idx.column() == 0 && role == Qt::ToolTipRole)
 217     {
 218     return this->data(idx, Qt::DisplayRole).toString() + "\n" +
 219            this->data(idx, QCMakeCacheModel::HelpRole).toString();
 220     }
 221   else if(idx.column() == 1 && (role == Qt::DisplayRole || role == Qt::EditRole))
 222     {
 223     if(this->Properties[idx.row()].Type != QCMakeCacheProperty::BOOL)
 224       {
 225       return this->Properties[idx.row()].Value;
 226       }
 227     }
 228   else if(idx.column() == 1 && role == Qt::CheckStateRole)
 229     {
 230     if(this->Properties[idx.row()].Type == QCMakeCacheProperty::BOOL)
 231       {
 232       return this->Properties[idx.row()].Value.toBool() ? Qt::Checked : Qt::Unchecked;
 233       }
 234     }
 235   else if(role == QCMakeCacheModel::HelpRole)
 236     {
 237     return this->Properties[idx.row()].Help;
 238     }
 239   else if(role == QCMakeCacheModel::TypeRole)
 240     {
 241     return this->Properties[idx.row()].Type;
 242     }
 243   else if(role == QCMakeCacheModel::AdvancedRole)
 244     {
 245     return this->Properties[idx.row()].Advanced;
 246     }
 247   else if(role == Qt::BackgroundRole && idx.row()+1 <= this->NewCount)
 248     {
 249     return QBrush(QColor(255,100,100));
 250     }
 251   return QVariant();
 252 }
 253
 254 QModelIndex QCMakeCacheModel::parent (const QModelIndex& /*idx*/) const
 255 {
 256   return QModelIndex();
 257 }
 258
 259 int QCMakeCacheModel::rowCount (const QModelIndex& p) const
 260 {
 261   if(p.isValid())
 262     {
 263     return 0;
 264     }
 265   return this->Properties.count();
 266 }
 267
 268 QVariant QCMakeCacheModel::headerData (int section, Qt::Orientation orient, int role) const
 269 {
 270   // return header labels
 271   if(role == Qt::DisplayRole && orient == Qt::Horizontal)
 272     {
 273     return section == 0 ? "Name" : "Value";
 274     }
 275   return QVariant();
 276 }
 277
 278 Qt::ItemFlags QCMakeCacheModel::flags (const QModelIndex& idx) const
 279 {
 280   Qt::ItemFlags f = Qt::ItemIsEnabled | Qt::ItemIsSelectable;
 281   // all column 1's are editable
 282   if(idx.column() == 1 && this->EditEnabled)
 283     {
 284     f |= Qt::ItemIsEditable;
 285     // booleans are editable in place
 286     if(this->Properties[idx.row()].Type == QCMakeCacheProperty::BOOL)
 287       {
 288       f |= Qt::ItemIsUserCheckable;
 289       }
 290     }
 291   return f;
 292 }
 293
 294
 295 bool QCMakeCacheModel::setData (const QModelIndex& idx, const QVariant& value, int role)
 296 {
 297   if(idx.column() == 0 && (role == Qt::DisplayRole || role == Qt::EditRole))
 298     {
 299     this->Properties[idx.row()].Key = value.toString();
 300     emit this->dataChanged(idx, idx);
 301     }
 302   else if(idx.column() == 1 && (role == Qt::DisplayRole || role == Qt::EditRole))
 303     {
 304     this->Properties[idx.row()].Value = value.toString();
 305     emit this->dataChanged(idx, idx);
 306     }
 307   else if(idx.column() == 1 && (role == Qt::CheckStateRole))
 308     {
 309     this->Properties[idx.row()].Value = value.toInt() == Qt::Checked;
 310     emit this->dataChanged(idx, idx);
 311     }
 312   else if(role == QCMakeCacheModel::HelpRole)
 313     {
 314     this->Properties[idx.row()].Help = value.toString();
 315     emit this->dataChanged(idx, idx);
 316     }
 317   else if(role == QCMakeCacheModel::TypeRole)
 318     {
 319     this->Properties[idx.row()].Type = static_cast<QCMakeCacheProperty::PropertyType>(value.toInt());
 320     }
 321   else if(role == QCMakeCacheModel::AdvancedRole)
 322     {
 323     this->Properties[idx.row()].Advanced = value.toBool();
 324     }
 325   return false;
 326 }
 327
 328 QModelIndex QCMakeCacheModel::buddy(const QModelIndex& idx) const
 329 {
 330   if(idx.column() == 0)
 331     {
 332     if(this->Properties[idx.row()].Type != QCMakeCacheProperty::BOOL)
 333       {
 334       return this->index(idx.row(), 1);
 335       }
 336     }
 337   return idx;
 338 }
 339
 340 bool QCMakeCacheModel::removeRows(int row, int num, const QModelIndex&)
 341 {
 342   if(row < 0 || row+num > this->Properties.count())
 343     {
 344     return false;
 345     }
 346   this->beginRemoveRows(QModelIndex(), row, row+num-1);
 347   for(int i=0; i<num; i++)
 348     {
 349     this->Properties.removeAt(row);
 350     if(this->NewCount >= row+1)
 351       {
 352       this->NewCount--;
 353       }
 354     }
 355   this->endRemoveRows();
 356   return true;
 357 }
 358
 359 bool QCMakeCacheModel::insertRows(int row, int num, const QModelIndex&)
 360 {
 361   if(row < 0)
 362     row = 0;
 363   if(row > this->rowCount())
 364     row = this->rowCount();
 365
 366   this->beginInsertRows(QModelIndex(), row, row+num-1);
 367   for(int i=0; i<num; i++)
 368     {
 369     this->Properties.insert(row+i, QCMakeCacheProperty());
 370     if(this->NewCount >= row)
 371       {
 372       this->NewCount++;
 373       }
 374     }
 375   this->endInsertRows();
 376   return true;
 377 }
 378
 379 QCMakeCacheModelDelegate::QCMakeCacheModelDelegate(QObject* p)
 380   : QItemDelegate(p), FileDialogFlag(false)
 381 {
 382 }
 383
 384 void QCMakeCacheModelDelegate::setFileDialogFlag(bool f)
 385 {
 386   this->FileDialogFlag = f;
 387 }
 388
 389 QWidget* QCMakeCacheModelDelegate::createEditor(QWidget* p,
 390     const QStyleOptionViewItem&, const QModelIndex& idx) const
 391 {
 392   const QAbstractItemModel* model = idx.model();
 393   QModelIndex var = model->index(idx.row(), 0);
 394   QVariant type = idx.data(QCMakeCacheModel::TypeRole);
 395   if(type == QCMakeCacheProperty::BOOL)
 396     {
 397     return NULL;
 398     }
 399   else if(type == QCMakeCacheProperty::PATH)
 400     {
 401     QCMakeCachePathEditor* editor =
 402       new QCMakeCachePathEditor(p,
 403       var.data(Qt::DisplayRole).toString());
 404     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 405         SLOT(setFileDialogFlag(bool)));
 406     return editor;
 407     }
 408   else if(type == QCMakeCacheProperty::FILEPATH)
 409     {
 410     QCMakeCacheFilePathEditor* editor =
 411       new QCMakeCacheFilePathEditor(p,
 412       var.data(Qt::DisplayRole).toString());
 413     QObject::connect(editor, SIGNAL(fileDialogExists(bool)), this,
 414         SLOT(setFileDialogFlag(bool)));
 415     return editor;
 416     }
 417
 418   return new QLineEdit(p);
 419 }
 420
 421 bool QCMakeCacheModelDelegate::editorEvent(QEvent* e, QAbstractItemModel* model,
 422        const QStyleOptionViewItem& option, const QModelIndex& index)
 423 {
 424   Qt::ItemFlags flags = model->flags(index);
 425   if (!(flags & Qt::ItemIsUserCheckable) || !(option.state & QStyle::State_Enabled)
 426       || !(flags & Qt::ItemIsEnabled))
 427     {
 428     return false;
 429     }
 430
 431   QVariant value = index.data(Qt::CheckStateRole);
 432   if (!value.isValid())
 433     {
 434     return false;
 435     }
 436
 437   if ((e->type() == QEvent::MouseButtonRelease)
 438       || (e->type() == QEvent::MouseButtonDblClick))
 439     {
 440     // eat the double click events inside the check rect
 441     if (e->type() == QEvent::MouseButtonDblClick)
 442       {
 443       return true;
 444       }
 445     }
 446   else if (e->type() == QEvent::KeyPress)
 447     {
 448     if(static_cast<QKeyEvent*>(e)->key() != Qt::Key_Space &&
 449        static_cast<QKeyEvent*>(e)->key() != Qt::Key_Select)
 450       {
 451       return false;
 452       }
 453     }
 454   else
 455     {
 456     return false;
 457     }
 458
 459   Qt::CheckState state = (static_cast<Qt::CheckState>(value.toInt()) == Qt::Checked
 460                           ? Qt::Unchecked : Qt::Checked);
 461   return model->setData(index, state, Qt::CheckStateRole);
 462 }
 463
 464 bool QCMakeCacheModelDelegate::eventFilter(QObject* object, QEvent* event)
 465 {
 466   // workaround for what looks like a bug in Qt on Mac OS X
 467   if(event->type() == QEvent::FocusOut && this->FileDialogFlag)
 468   {
 469     return false;
 470   }
 471   return QItemDelegate::eventFilter(object, event);
 472 }
 473
 474
 475 QCMakeCacheFileEditor::QCMakeCacheFileEditor(QWidget* p, const QString& var)
 476   : QLineEdit(p), Variable(var)
 477 {
 478   // this *is* instead of has a line edit so QAbstractItemView
 479   // doesn't get confused with what the editor really is
 480   this->setContentsMargins(0, 0, 0, 0);
 481   this->ToolButton = new QToolButton(this);
 482   this->ToolButton->setText("...");
 483   this->ToolButton->setCursor(QCursor(Qt::ArrowCursor));
 484   QObject::connect(this->ToolButton, SIGNAL(clicked(bool)),
 485                    this, SLOT(chooseFile()));
 486 }
 487
 488 QCMakeCacheFilePathEditor::QCMakeCacheFilePathEditor(QWidget* p, const QString& var)
 489  : QCMakeCacheFileEditor(p, var)
 490 {
 491   this->setCompleter(new QCMakeFileCompleter(this, false));
 492 }
 493
 494 QCMakeCachePathEditor::QCMakeCachePathEditor(QWidget* p, const QString& var)
 495  : QCMakeCacheFileEditor(p, var)
 496 {
 497 this->setCompleter(new QCMakeFileCompleter(this, true));
 498 }
 499
 500 void QCMakeCacheFileEditor::resizeEvent(QResizeEvent* e)
 501 {
 502   // make the tool button fit on the right side
 503   int h = e->size().height();
 504   this->ToolButton->resize(h, h);
 505   this->ToolButton->move(this->width() - h, 0);
 506   this->setContentsMargins(0, 0, h, 0);
 507 }
 508
 509 void QCMakeCacheFilePathEditor::chooseFile()
 510 {
 511   // choose a file and set it
 512   QString path;
 513   QFileInfo info(this->text());
 514   QString title;
 515   if(this->Variable.isEmpty())
 516     {
 517     title = tr("Select File");
 518     }
 519   else
 520     {
 521     title = tr("Select File for %1");
 522     title = title.arg(this->Variable);
 523     }
 524   this->fileDialogExists(true);
 525   path = QFileDialog::getOpenFileName(this, title, info.absolutePath());
 526   this->fileDialogExists(false);
 527
 528   if(!path.isEmpty())
 529     {
 530     this->setText(QDir::fromNativeSeparators(path));
 531     }
 532 }
 533
 534 void QCMakeCachePathEditor::chooseFile()
 535 {
 536   // choose a file and set it
 537   QString path;
 538   QString title;
 539   if(this->Variable.isEmpty())
 540     {
 541     title = tr("Select Path");
 542     }
 543   else
 544     {
 545     title = tr("Select Path for %1");
 546     title = title.arg(this->Variable);
 547     }
 548   this->fileDialogExists(true);
 549   path = QFileDialog::getExistingDirectory(this, title, this->text());
 550   this->fileDialogExists(false);
 551   if(!path.isEmpty())
 552     {
 553     this->setText(QDir::fromNativeSeparators(path));
 554     }
 555 }
 556
 557 QCMakeFileCompleter::QCMakeFileCompleter(QObject* o, bool dirs)
 558   : QCompleter(o)
 559 {
 560   QDirModel* model = new QDirModel(this);
 561   if(dirs)
 562     {
 563     model->setFilter(QDir::AllDirs | QDir::Drives | QDir::NoDotAndDotDot);
 564     }
 565   this->setModel(model);
 566 }
 567
 568 QString QCMakeFileCompleter::pathFromIndex(const QModelIndex& idx) const
 569 {
 570   return QDir::fromNativeSeparators(QCompleter::pathFromIndex(idx));
 571 }
 572