/** Submit the current editing class/interactor to the model and submit the model to the database */
void InteractorEditorWidget::save()
{
if (d->m_EditingIndex.isValid()) {
QAbstractItemModel *model = ddiCore()->drugInteractorTableModel();
// Manage ATC
QModelIndex atc = model->index(d->m_EditingIndex.row(), DrugInteractorTableModel::ATCCodeStringList, d->m_EditingIndex.parent());
model->setData(atc, d->_atcCodesStringListModel->stringList().join(";"));
// Manage class children
QModelIndex children = model->index(d->m_EditingIndex.row(), DrugInteractorTableModel::ChildrenUuid, d->m_EditingIndex.parent());
model->setData(children, d->_childrenInteractorsStringListModel->stringList().join(";"));
// Manage PMIDs
QModelIndex pmids = model->index(d->m_EditingIndex.row(), DrugInteractorTableModel::PMIDStringList, d->m_EditingIndex.parent());
model->setData(pmids, d->_pmidStringListModel->stringList().join(";"));
// Submit mapper at the end as the model will be resetted on submit
if (!d->_mapper->submit())
LOG_ERROR("Unable to submit mapper");
}
setEditorsEnabled(false);
d->aSave->setEnabled(false);
d->aRevert->setEnabled(false);
d->_proxyMoleculeModel->invalidate();
d->_proxyMoleculeModel->setFilterFixedString(d->ui->searchLine->text());
updateCounts();
}
void MetaEditor::insertRow(QString code, QString contents)
{
QModelIndex index = view->selectionModel()->currentIndex();
QAbstractItemModel *model = view->model();
// force all row insertions to be children of the root item
while(index.parent() != QModelIndex()) {
index = index.parent();
}
if (!model->insertRow(index.row()+1, index.parent()))
return;
updateActions();
QModelIndex child = model->index(index.row()+1, 0, index.parent());
model->setData(child, QVariant(code), Qt::EditRole);
for (int column = 1; column < model->columnCount(index.parent()); ++column) {
QModelIndex nchild = model->index(index.row()+1, column, index.parent());
if (!contents.isEmpty()) {
model->setData(nchild, QVariant(contents), Qt::EditRole);
} else {
model->setData(nchild, QVariant(tr("[Your value here]")), Qt::EditRole);
}
}
// force newly inserted row to be the currently selected item so that any
// follow-on insertChild calls use this as their parent.
view->selectionModel()->setCurrentIndex(child, QItemSelectionModel::ClearAndSelect);
updateActions();
}
void QgsJoinDialog::setJoinInfo( const QgsVectorJoinInfo& joinInfo )
{
mJoinLayerComboBox->setLayer( QgsMapLayerRegistry::instance()->mapLayer( joinInfo.joinLayerId ) );
mJoinFieldComboBox->setField( joinInfo.joinFieldName );
mTargetFieldComboBox->setField( joinInfo.targetFieldName );
mCacheInMemoryCheckBox->setChecked( joinInfo.memoryCache );
if ( joinInfo.prefix.isNull() )
{
mUseCustomPrefix->setChecked( false );
}
else
{
mUseCustomPrefix->setChecked( true );
mCustomPrefix->setText( joinInfo.prefix );
}
QStringList* lst = joinInfo.joinFieldNamesSubset();
mUseJoinFieldsSubset->setChecked( lst && !lst->isEmpty() );
QAbstractItemModel* model = mJoinFieldsSubsetView->model();
if ( model )
{
for ( int i = 0; i < model->rowCount(); ++i )
{
QModelIndex index = model->index( i, 0 );
if ( lst && lst->contains( model->data( index, Qt::DisplayRole ).toString() ) )
{
model->setData( index, Qt::Checked, Qt::CheckStateRole );
}
else
{
model->setData( index, Qt::Unchecked, Qt::CheckStateRole );
}
}
}
}
void LogDetailWidget::setupModel()
{
QAbstractItemModel *model = pieChart->model();
model->setHeaderData(0, Qt::Horizontal, tr("Label"));
model->setHeaderData(1, Qt::Horizontal, tr("Quantity"));
QString colors[] = {"#ff0000", "#00ff00", "#0000ff","#ffff00", "#ff00ff", "#00ffff", "#000000", "#ffffff", "#777777", "#222222", "#aaaaaa"};
int i=0;
for(hash_map<string, double>::iterator it = logMan.process_stat.begin() ; it != logMan.process_stat.end(); it++)
{
string process = it->first;
double duration = it->second;
model->insertRow(i);
model->setData(model->index(i, 0), QString::fromStdString(process));
model->setData(model->index(i, 1), duration);
model->setData(model->index(i, 0, QModelIndex()),
QColor(colors[i]), Qt::DecorationRole);
i++;
}
}
/*
void AdjustNames::resizeEvent( QResizeEvent * event )
{
int w = event->size().width();
int h = event->size().height();
BackFrame->resize(event->size());
if( w > 300 && h > 150 )
{
Cancel->setGeometry(w-85,h-36,77,26);
Next->setGeometry(w-168,h-36,77,26);
line->setGeometry(14,h-53,w-21,16);
title->setGeometry(220,21,w-299,18);
instructions->setGeometry(220,h-79,w-229,18);
tableWidget->setGeometry(220, 45, w-229, h-130);
}
}
*/
void AdjustNames::show()
{
QDialog::show();
scenarioName->setText(QString( "Scenario Name: ") + extractor->setup->scenarioName->text());
scenarioDirectory->setText(QString("Scenario Directory: ") + extractor->setup->scenarioDirectory->text());
tableWidget->clearContents();
tableWidget->setRowCount(0);
tableWidget->horizontalHeaderItem(0)->setToolTip("This is the node id used by the EXata/QualNet simulator and GUI");
tableWidget->horizontalHeaderItem(1)->setToolTip("This is the name used by the HLA federate that published the entity");
tableWidget->horizontalHeaderItem(2)->setToolTip("Enter text to change the name that will be used by the EXata/QualNet simulator and GUI");
tableWidget->horizontalHeaderItem(3)->setToolTip("Enter an icon file name or browse to change the icon used by the EXata/QualNet simulator and GUI");
QAbstractItemModel* model = tableWidget->model();
SNT_HLA::NodeSet::iterator it = extractor->ns->begin();
//QFontMetrics fontMetrics = tableWidget->fontMetrics();
//int iconWidth = 0;
while( it != extractor->ns->end() )
{
QApplication::processEvents();
if( extractor == 0 )
break;
if( (*it)->entity )
{
QString name((*it)->getNodeName());
int id = (*it)->NodeId;
QString iconName((*it)->getIconName().c_str());
QIcon icon(iconName);
QFileInfo iconInfo(iconName);
int row = tableWidget->rowCount();
tableWidget->insertRow(row);
QModelIndex index = model->index(row, 1, QModelIndex());
model->setData(index, name);
index = model->index(row, 2, QModelIndex());
model->setData(index, name);
index = model->index(row, 0, QModelIndex());
model->setData(index, id);
tableWidget->item(row, 0)->setFlags(0);
tableWidget->item(row, 1)->setFlags(0);
FileNameWidget* wid = new FileNameWidget("Open Icon File", extractor->exeHome+"/gui/icons", getImageFilter(),tableWidget);
wid->setText(iconName);
wid->setToolTip("Enter an icon file name or browse to change the icon used by the EXata/QualNet simulator and GUI");
tableWidget->setCellWidget(row, 3, wid);
tableWidget->item(row,0)->setToolTip("This is the node id used by the EXata/QualNet simulator and GUI");
tableWidget->item(row,1)->setToolTip("This is the name used by the HLA federate that published the entity");
tableWidget->item(row,2)->setToolTip("Enter text to change the name that will be used by the EXata/QualNet simulator and GUI");
tableWidget->resizeColumnToContents(0);
tableWidget->resizeColumnToContents(1);
tableWidget->resizeColumnToContents(2);
}
//tableWidget->setColumnWidth(3, iconWidth);
it++;
}
}
void MainWindow::insertChild()
{
QModelIndex index = view->selectionModel()->currentIndex();
QAbstractItemModel *model = view->model();
if (model->columnCount(index) == 0) {
if (!model->insertColumn(0, index))
return;
}
if (!model->insertRow(0, index))
return;
for (int column = 0; column < model->columnCount(index); ++column) {
QModelIndex child = model->index(0, column, index);
model->setData(child, QVariant("[No data]"), Qt::EditRole);
if (!model->headerData(column, Qt::Horizontal).isValid())
model->setHeaderData(column, Qt::Horizontal, QVariant("[No header]"),
Qt::EditRole);
}
view->selectionModel()->setCurrentIndex(model->index(0, 0, index),
QItemSelectionModel::ClearAndSelect);
updateActions();
}
//! [0]
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
// Unindented for quoting purposes:
//! [1]
QStringList numbers;
numbers << "One" << "Two" << "Three" << "Four" << "Five";
QAbstractItemModel *model = new StringListModel(numbers);
//! [0] //! [1] //! [2] //! [3]
QListView *view = new QListView;
//! [2]
view->setWindowTitle("View onto a string list model");
//! [4]
view->setModel(model);
//! [3] //! [4]
model->insertRows(5, 7, QModelIndex());
for (int row = 5; row < 12; ++row) {
QModelIndex index = model->index(row, 0, QModelIndex());
model->setData(index, QString::number(row+1));
}
//! [5]
view->show();
return app.exec();
}
void testUpdate()
{
const QgsKeyValueWidgetFactory factory( QStringLiteral( "testKeyValue" ) );
QgsEditorWidgetWrapper* wrapper = factory.create( nullptr, 0, nullptr, nullptr );
QVERIFY( wrapper );
QSignalSpy spy( wrapper, SIGNAL( valueChanged( const QVariant& ) ) );
QgsKeyValueWidget* widget = qobject_cast< QgsKeyValueWidget* >( wrapper->widget() );
QVERIFY( widget );
QVariantMap initial;
initial[QStringLiteral( "1" )] = "one";
initial[QStringLiteral( "2" )] = "two";
wrapper->setValue( initial );
const QVariant value = wrapper->value();
QCOMPARE( int( value.type() ), int( QVariant::Map ) );
QCOMPARE( value.toMap(), initial );
QCOMPARE( spy.count(), 0 );
QAbstractItemModel* model = widget->tableView->model();
model->setData( model->index( 0, 1 ), "hello" );
QCOMPARE( spy.count(), 1 );
QVariantMap expected = initial;
expected[QStringLiteral( "1" )] = "hello";
QVariant eventValue = spy.at( 0 ).at( 0 ).value<QVariant>();
QCOMPARE( int( eventValue.type() ), int( QVariant::Map ) );
QCOMPARE( eventValue.toMap(), expected );
QCOMPARE( wrapper->value().toMap(), expected );
QCOMPARE( spy.count(), 1 );
}
void PreferencesDialog::cellChanged(int row, int column) {
if (row == 3) {
// force selection color to be the same for nodes & edges
QAbstractItemModel* model = _ui->graphDefaultsTable->model();
model->setData(model->index(3, column == 1 ? 2 : 1), model->data(model->index(3,column)));
}
}
void Element::setRoleValueByName(QString const &roleName, QString const &value)
{
int roleIndex = roleIndexByName(roleName);
if (roleIndex < roles::customPropertiesBeginRole)
return;
QAbstractItemModel *itemModel = const_cast<QAbstractItemModel*>(mDataIndex.model());
itemModel->setData(mDataIndex, value, roleIndex);
}
void Desktopwidget::pageRight (const QModelIndex &index)
{
QAbstractItemModel *model = (QAbstractItemModel *)index.model ();
int pagenum = model->data (index, Desktopmodel::Role_pagenum).toInt ();
QVariant v = pagenum + 1;
model->setData (index, v, Desktopmodel::Role_pagenum);
}
void tst_QDataWidgetMapper::comboBox()
{
QDataWidgetMapper mapper;
QAbstractItemModel *model = testModel(&mapper);
mapper.setModel(model);
mapper.setSubmitPolicy(QDataWidgetMapper::ManualSubmit);
QComboBox readOnlyBox;
readOnlyBox.setEditable(false);
readOnlyBox.addItem("read only item 0");
readOnlyBox.addItem("read only item 1");
readOnlyBox.addItem("read only item 2");
QComboBox readWriteBox;
readWriteBox.setEditable(true);
readWriteBox.addItem("read write item 0");
readWriteBox.addItem("read write item 1");
readWriteBox.addItem("read write item 2");
// populat the combo boxes with data
mapper.addMapping(&readOnlyBox, 0, "currentIndex");
mapper.addMapping(&readWriteBox, 1, "currentText");
mapper.toFirst();
QCOMPARE(readOnlyBox.currentText(), QString("read only item 0"));
QCOMPARE(readWriteBox.currentText(), QString("read write item 0"));
// set some new values on the boxes
readOnlyBox.setCurrentIndex(1);
readWriteBox.setEditText("read write item y");
mapper.submit();
// make sure the new values are in the model
QCOMPARE(model->data(model->index(0, 0)).toInt(), 1);
QCOMPARE(model->data(model->index(0, 1)).toString(), QString("read write item y"));
// now test updating of the widgets
model->setData(model->index(0, 0), 2, Qt::EditRole);
model->setData(model->index(0, 1), QString("read write item z"), Qt::EditRole);
QCOMPARE(readOnlyBox.currentIndex(), 2);
QEXPECT_FAIL("", "See task 125493 and QTBUG-428", Abort);
QCOMPARE(readWriteBox.currentText(), QString("read write item z"));
}
bool KConcatenateRowsProxyModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
const QModelIndex sourceIndex = mapToSource(index);
if (!sourceIndex.isValid()) {
return false;
}
QAbstractItemModel *sourceModel = const_cast<QAbstractItemModel *>(sourceIndex.model());
return sourceModel->setData(sourceIndex, value, role);
}
void DlgFilletEdges::on_selectNoneButton_clicked()
{
QAbstractItemModel* model = ui->treeView->model();
for (int i=0; i<model->rowCount(); ++i) {
Qt::CheckState checkState = Qt::Unchecked;
QVariant value(static_cast<int>(checkState));
model->setData(model->index(i,0), value, Qt::CheckStateRole);
}
}
void TodoNode::setRowData(const QVariant &value, int role)
{
if (m_rowSourceIndex.isValid()) {
QAbstractItemModel *model = const_cast<QAbstractItemModel*>(m_rowSourceIndex.model());
model->setData(m_rowSourceIndex, value, role);
} else {
m_data[QPair<int, int>(-1, role)] = value;
}
}
void SummaryHandlingProxyModel::Private::insertInCache( const SummaryHandlingProxyModel* model,
const QModelIndex& sourceIdx ) const
{
QAbstractItemModel* sourceModel = model->sourceModel();
const QModelIndex& mainIdx = sourceIdx;
QDateTime st;
QDateTime et;
for ( int r = 0; r < sourceModel->rowCount( mainIdx ); ++r ) {
QModelIndex pdIdx = model->mapFromSource( sourceModel->index( r, 0, mainIdx ) );
/* The probably results in recursive calls here */
QVariant tmpsv = model->data( pdIdx, StartTimeRole );
QVariant tmpev = model->data( pdIdx, EndTimeRole );
if( !qVariantCanConvert<QDateTime>(tmpsv) ||
!qVariantCanConvert<QDateTime>(tmpev) ) {
qDebug() << "Skipping item " << sourceIdx << " because it doesn't contain QDateTime";
continue;
}
// check for valid datetimes
if( tmpsv.type() == QVariant::DateTime && !qVariantValue<QDateTime>(tmpsv).isValid()) continue;
if( tmpev.type() == QVariant::DateTime && !qVariantValue<QDateTime>(tmpev).isValid()) continue;
// We need to test for empty strings to
// avoid a stupid Qt warning
if( tmpsv.type() == QVariant::String && qVariantValue<QString>(tmpsv).isEmpty()) continue;
if( tmpev.type() == QVariant::String && qVariantValue<QString>(tmpev).isEmpty()) continue;
QDateTime tmpst = tmpsv.toDateTime();
QDateTime tmpet = tmpev.toDateTime();
if ( st.isNull() || st > tmpst ) st = tmpst;
if ( et.isNull() || et < tmpet ) et = tmpet;
}
QVariant tmpssv = sourceModel->data( mainIdx, StartTimeRole );
QVariant tmpsev = sourceModel->data( mainIdx, EndTimeRole );
if ( qVariantCanConvert<QDateTime>( tmpssv )
&& !( qVariantCanConvert<QString>( tmpssv ) && qVariantValue<QString>( tmpssv ).isEmpty() )
&& qVariantValue<QDateTime>( tmpssv ) != st )
sourceModel->setData( mainIdx, st, StartTimeRole );
if ( qVariantCanConvert<QDateTime>( tmpsev )
&& !( qVariantCanConvert<QString>( tmpsev ) && qVariantValue<QString>( tmpsev ).isEmpty() )
&& qVariantValue<QDateTime>( tmpsev ) != et )
sourceModel->setData( mainIdx, et, EndTimeRole );
cached_summary_items[sourceIdx]=qMakePair( st, et );
}
void PathPlanningWidget::pointPosUpdated_slot(const tf::Transform& point_pos, const char* marker_name)
{
/*! When the user updates the position of the Way-Point or the User Interactive Marker, the information in the TreeView also needs to be updated to correspond to the current pose of the InteractiveMarkers.
*/
QAbstractItemModel *model = ui_.treeView->model();
ROS_INFO_STREAM("Updating marker name:"<<marker_name);
tf::Vector3 p = point_pos.getOrigin();
tfScalar rx,ry,rz;
point_pos.getBasis().getRPY(rx,ry,rz,1);
rx = RAD2DEG(rx);
ry = RAD2DEG(ry);
rz = RAD2DEG(rz);
if((strcmp(marker_name,"add_point_button") == 0) || (atoi(marker_name)==0))
{
QString pos_s;
pos_s = QString::number(p.x()) + "; " + QString::number(p.y()) + "; " + QString::number(p.z()) + ";";
QString orient_s;
orient_s = QString::number(rx) + "; " + QString::number(ry) + "; " + QString::number(rz) + ";";
model->setData(model->index(0,0),QVariant("add_point_button"),Qt::EditRole);
model->setData(model->index(0,1),QVariant(pos_s),Qt::EditRole);
model->setData(model->index(0,2),QVariant(orient_s),Qt::EditRole);
}
else
{
int changed_marker = atoi(marker_name);
//**********************update the positions and orientations of the children as well***********************************************************************************************
QModelIndex ind = model->index(changed_marker, 0);
QModelIndex chldind_pos = model->index(0, 0, ind);
QModelIndex chldind_orient = model->index(1, 0, ind);
//set the strings of each axis of the position
QString pos_x = QString::number(p.x());
QString pos_y = QString::number(p.y());
QString pos_z = QString::number(p.z());
//repeat that with the orientation
QString orient_x = QString::number(rx);
QString orient_y = QString::number(ry);
QString orient_z = QString::number(rz);
//second we add the current position information, for each position axis separately
model->setData(model->index(0, 1, chldind_pos), QVariant(pos_x), Qt::EditRole);
model->setData(model->index(1, 1, chldind_pos), QVariant(pos_y), Qt::EditRole);
model->setData(model->index(2, 1, chldind_pos), QVariant(pos_z), Qt::EditRole);
//second we add the current position information, for each position axis separately
model->setData(model->index(0, 2, chldind_orient), QVariant(orient_x), Qt::EditRole);
model->setData(model->index(1, 2, chldind_orient), QVariant(orient_y), Qt::EditRole);
model->setData(model->index(2, 2, chldind_orient), QVariant(orient_z), Qt::EditRole);
//*****************************************************************************************************************************************************************************************
}
}
void PreviewsSettingsPage::loadPreviewPlugins()
{
QAbstractItemModel* model = m_listView->model();
const KService::List plugins = KServiceTypeTrader::self()->query(QLatin1String("ThumbCreator"));
foreach (const KSharedPtr<KService>& service, plugins) {
const bool configurable = service->property("Configurable", QVariant::Bool).toBool();
const bool show = m_enabledPreviewPlugins.contains(service->desktopEntryName());
model->insertRow(0);
const QModelIndex index = model->index(0, 0);
model->setData(index, show, Qt::CheckStateRole);
model->setData(index, configurable, ServiceModel::ConfigurableRole);
model->setData(index, service->name(), Qt::DisplayRole);
model->setData(index, service->desktopEntryName(), ServiceModel::DesktopEntryNameRole);
}
model->sort(Qt::DisplayRole);
}
void CTestAlgorithmSettings::test()
{
AWorkflow* workflow = CWorkflowManager::Instance()->getWorkflow("4Phase Workflow");
QVector<IPlugin*> plugins = CPluginManager::Instance()->getPlugins();
bool pluginFound = false;
for(IPlugin* p : plugins)
{
if(p->Name() == "AlgorithmSettingsTest")
{
workflow->trySetStep(0, p);
pluginFound = true;
break;
}
}
QCOMPARE(pluginFound, true);
if(pluginFound)
{
CAlgorithmSettingsView* settingsView = new CAlgorithmSettingsView;
QAbstractItemModel* model = nullptr;
QModelIndex index;
settingsView->setWorkflow(*workflow);
model = static_cast<QTreeView*>(settingsView)->model();
index = model->index(0, 0, settingsView->rootIndex());
index = model->index(0, 1, index);
mSettingsSet = false;
model->setData(index, QVariant(TEST_VALUE_VALID));
QVERIFY(mSettingsSet);
QCOMPARE(mSettings.value("parameter").toInt(), TEST_VALUE_VALID);
mSettingsSet = false;
model->setData(index, QVariant(TEST_VALUE_INVALID));
QVERIFY(!mSettingsSet);
delete settingsView;
}
delete workflow;
}
QAbstractItemModel * radDataWidget :: initComplexModel (const complex<double> * zVec, int n)
{
if (!zVec || n==0)
return 0;
QAbstractItemModel * cModel = new QStandardItemModel (n, 2);
cModel->setHeaderData (0, Qt::Horizontal, tr("Real component"), Qt::DisplayRole);
cModel->setHeaderData (1, Qt::Horizontal, tr("Image component"), Qt::DisplayRole);
for (int i=0; i<n; i++)
{
double r = real(zVec[i]);
double im = imag(zVec[i]);
QModelIndex cRInd = cModel->index (i, 0);
cModel->setData (cRInd, QString::number (r, 'f', 16), Qt::DisplayRole);
QModelIndex cImInd = cModel->index (i, 1);
cModel->setData (cImInd, QString::number (im, 'f', 16), Qt::DisplayRole);
}
return cModel;
}
void SequentialFitDialog::addFile()
{
QFileDialog dlg(this);
dlg.setFileMode(QFileDialog::ExistingFiles);
const std::vector<std::string>& searchDirs =
Mantid::Kernel::ConfigService::Instance().getDataSearchDirs();
QString dir;
if ( searchDirs.empty() )
{
dir = "";
}
else
{
dir = QString::fromStdString(searchDirs.front());
}
dlg.setDirectory(dir);
if (dlg.exec())
{
QStringList fileNames;
fileNames = dlg.selectedFiles();
if (fileNames.isEmpty()) return;
fileNames.sort();
int row = ui.tWorkspaces->rowCount();
ui.tWorkspaces->model()->insertRows(row,fileNames.size());
//int wi = m_fitBrowser->workspaceIndex();
QAbstractItemModel* model = ui.tWorkspaces->model();
foreach(QString name,fileNames)
{
model->setData(model->index(row,0,QModelIndex()),name); // file name
model->setData(model->index(row,1,QModelIndex()),ui.sbPeriod->value()); // period
model->setData(model->index(row,2,QModelIndex()),ui.sbSpectrum->value()); // spectrum
model->setData(model->index(row,3,QModelIndex()),""); // ws index
QTableWidgetItem* item = ui.tWorkspaces->item(row,3);
if (item)
{
item->setBackgroundColor(QColor(Qt::lightGray));
item->setFlags(Qt::NoItemFlags);
}
++row;
}
bool ProxyModel::setData( const QModelIndex& proxyIdx, const QVariant& value, int role )
{
int srole = role;
int scol = proxyIdx.column();
QHash<int, int>::const_iterator it = d->roleMap.constFind( role );
if ( it != d->roleMap.constEnd() ) srole = *it;
it = d->columnMap.constFind( role );
if ( it != d->columnMap.constEnd() ) scol = *it;
QAbstractItemModel* model = sourceModel();
return model->setData( model->index( proxyIdx.row(), scol, mapToSource( proxyIdx.parent() ) ), value, srole );
}
/**
* \brief Update the progress bar
* @param id as the downloaded file id
* @param crnt as the current transfered size
* @param total as the total size of the file
*/
void UBDownloadWidget::onDownloadUpdated(int id, qint64 crnt, qint64 total)
{
if(NULL != mpTree)
{
QAbstractItemModel* model = mpTree->model();
if(NULL != model)
{
for(int i=0; i< model->rowCount(); i++)
{
QModelIndex currentIndex = model->index(i, eItemColumn_Desc);
if(id == currentIndex.data(Qt::UserRole + 2))
{
// We found the right item, now we update the progress bar
model->setData(currentIndex, crnt, Qt::UserRole);
model->setData(currentIndex, total, Qt::UserRole + 1);
break;
}
}
}
}
}
bool ModelCellModel::setData(const QModelIndex &index, const QVariant &value, int role)
{
if (index.isValid() && m_index.isValid()
&& (m_index.flags() & Qt::ItemIsEditable)
&& role == Qt::EditRole && index.column() == 1) {
const Qt::ItemDataRole sourceRole
= static_cast<Qt::ItemDataRole>(m_roles.at(index.row()).first);
QAbstractItemModel *sourceModel = const_cast<QAbstractItemModel *>(m_index.model());
return sourceModel->setData(m_index, value, sourceRole);
}
return QAbstractItemModel::setData(index, value, role);
}
void ConfigTabAppearance::decoratePreview()
{
if ( !m_itemFactory || !isVisible() )
return;
if (m_preview) {
delete m_preview;
m_preview = nullptr;
}
m_theme.updateTheme();
const auto sharedData = std::make_shared<ClipboardBrowserShared>();
sharedData->itemFactory = m_itemFactory;
sharedData->theme = m_theme;
auto c = new ClipboardBrowser(QString(), sharedData, this);
m_preview = c;
m_theme.decorateBrowser(c);
ui->browserParentLayout->addWidget(c);
const QString searchFor = tr("item", "Search expression in preview in Appearance tab.");
c->addItems( QStringList()
<< tr("Search string is %1.").arg( quoteString(searchFor) )
<< tr("Select an item and\n"
"press F2 to edit.") );
for (int i = 1; i <= 20; ++i)
c->add( tr("Example item %1").arg(i), -1 );
QAbstractItemModel *model = c->model();
QModelIndex index = model->index(0, 0);
QVariantMap dataMap;
dataMap.insert( mimeItemNotes, tr("Some random notes (Shift+F2 to edit)").toUtf8() );
model->setData(index, dataMap, contentType::updateData);
// Highlight found text but don't filter out any items.
c->filterItems( QRegExp(QString("|") + searchFor, Qt::CaseInsensitive) );
QAction *act;
act = new QAction(c);
act->setShortcut( QString("Shift+F2") );
connect(act, &QAction::triggered, c, &ClipboardBrowser::editNotes);
c->addAction(act);
act = new QAction(c);
act->setShortcut( QString("F2") );
connect(act, &QAction::triggered, c, &ClipboardBrowser::editSelected);
c->addAction(act);
}
void QtlCheckableHeaderView::updateAllRows()
{
QAbstractItemModel* model = this->model();
if (model != 0) {
const Qt::CheckState state = (_checkState == Qt::Unchecked) ? Qt::Unchecked : Qt::Checked;
for (int row = 0; row < model->rowCount(); row++) {
const QModelIndex index = model->index(row, 0);
if (index.isValid() && (model->flags(index) & Qt::ItemIsUserCheckable) != 0) {
model->setData(index, state, Qt::CheckStateRole);
}
}
}
}
void TracingLegend::addNode(NodeFacade* node)
{
int row = rows_.size();
rows_.push_back(node);
QAbstractItemModel* m = model();
m->insertRow(row);
m->setData(m->index(row, 0), QString::fromStdString(node->getLabel()));
resizeToFit();
Q_EMIT nodeAdded(node);
}
void WindowAnotationManager::on_btnAddBeat_clicked()
{
VideoDataClip *clip = ui->widgetStrainVideo->getClip();
if (!clip || clip->size() == 0) return;
int beat = ui->widgetStrainVideo->getCurrentIndex();
QAbstractItemModel *model = ui->listViewBeats->model();
int rowCount = model->rowCount();
model->insertRow(rowCount);
QModelIndex index = model->index(rowCount, 0);
model->setData(index, beat);
}
void MetaEditor::insertChild(QString code, QString contents)
{
QModelIndex index = view->selectionModel()->currentIndex();
QAbstractItemModel *model = view->model();
// restrict children to be a grandchild of the root item
// and make sure you are in column 0 when inserting a child
if (index.parent() != QModelIndex()) {
index = index.parent();
}
int row = index.row();
index = index.sibling(row,0);
if (model->columnCount(index) == 0) {
if (!model->insertColumn(0, index))
return;
}
if (!model->insertRow(0, index))
return;
QModelIndex child = model->index(0, 0, index);
model->setData(child, QVariant(code), Qt::EditRole);
for (int column = 1; column < model->columnCount(index); ++column) {
QModelIndex child = model->index(0, column, index);
if (!contents.isEmpty()) {
model->setData(child, QVariant(contents), Qt::EditRole);
} else {
model->setData(child, QVariant(tr("[Place value here]")), Qt::EditRole);
}
if (!model->headerData(column, Qt::Horizontal).isValid())
model->setHeaderData(column, Qt::Horizontal, QVariant("[No header]"), Qt::EditRole);
}
view->selectionModel()->setCurrentIndex(model->index(0, 0, index),
QItemSelectionModel::ClearAndSelect);
updateActions();
}
void ParamItem::setField(int column, double value) {
QAbstractItemModel* model
= const_cast<QAbstractItemModel*>(currentIndex.model());
model->setData(
model->index(currentIndex.row(), column, QModelIndex()), value);
}
