void StochasticProcessWidget::updateSelectAllColumn(
int index) {
bool allChecked = true;
bool allUnchecked = true;
for (int i = 0; i <= 2; i++) {
QTableWidgetItem *item = distGraphTable->item(
i, index);
if (item) {
bool isChecked = item->checkState()
== Qt::Checked;
bool isPartiallyChecked =
item->checkState()
== Qt::PartiallyChecked;
allChecked = allChecked && isChecked
&& !isPartiallyChecked;
allUnchecked = allUnchecked && !isChecked
&& !isPartiallyChecked;
}
}
QTableWidgetItem *selectAllItem =
distGraphTable->item(5, index);
if (selectAllItem) {
if (allChecked) {
selectAllItem->setCheckState(Qt::Checked);
} else if (allUnchecked) {
selectAllItem->setCheckState(Qt::Unchecked);
} else {
selectAllItem->setCheckState(Qt::PartiallyChecked);
}
}
}
void LiveEventControl::cellChangedSlot(int row, int column)
{
QTableWidgetItem *item = m_ui->panelTableWidget->item(row, column);
if (column == 0) { // Visible
emit setPanelVisible(row, item->checkState() == Qt::Checked);
}
else if (column == 2) { // Loop
emit loopPanel(row, item->checkState() == Qt::Checked);
}
else if (column == 4) { // Name
emit setPanelNameSignal(row, item->data(Qt::DisplayRole).toString());
}
}
bool ChartEditorWindow::createChartTable(){
bool ok;
QStringList selectedLayers;
// create table using the currently selected layers
for(int i=0; i < m_ui->tableWidgetSelect->rowCount(); i++){
QTableWidgetItem *item = m_ui->tableWidgetSelect->item(0, i);
if(item->checkState() == Qt::Checked)
selectedLayers << item->text();
}
chartTable.setSettings(chartTableSettings);
this->lvi = chartTable.generateLayerVisualInfoForAllTables(selectedLayers, &ok);
if(!ok){
showStatus("Error creating chart table.");
return false;
}
showChartTable();
//showLayers(); // don't update! must be selected before generation
showStatus("Generated chart table");
m_ui->actionSave->setEnabled(true);
m_ui->actionSaveAs->setEnabled(true);
return true;
}
void MainSettingsDialog::syncMappingSettings()
{
settings->beginGroup("Mappings");
settings->remove("");
for (int i=0; i < ui->controllerMappingsTableWidget->rowCount(); i++)
{
QTableWidgetItem *itemGUID = ui->controllerMappingsTableWidget->item(i, 0);
QTableWidgetItem *itemMapping = ui->controllerMappingsTableWidget->item(i, 1);
QTableWidgetItem *itemDisable = ui->controllerMappingsTableWidget->item(i, 2);
if (itemGUID && !itemGUID->text().isEmpty() && itemDisable)
{
bool disableController = itemDisable->checkState() == Qt::Checked ? true : false;
if (itemMapping && !itemMapping->text().isEmpty())
{
settings->setValue(itemGUID->text(), itemMapping->text());
}
settings->setValue(QString("%1Disable").arg(itemGUID->text()), disableController);
}
}
settings->endGroup();
}
void LandmarkRegistrationWidget::cellChangedSlot(int row, int column)
{
QTableWidgetItem* item = mLandmarkTableWidget->item(row, column);
QString uid = item->data(Qt::UserRole).toString();
if (column == 0)
{
QString name = item->text();
mServices->patient()->setLandmarkName(uid, name);
}
if (column == 1)
{
Qt::CheckState state = item->checkState();
mServices->patient()->setLandmarkActive(uid, state == Qt::Checked);
this->performRegistration(); // automatic when changing active state (Mantis #0000674)s
}
if (column == 2)
{
QString val = item->text();
// remove formatting stuff:
val = val.replace('(', " ");
val = val.replace(')', " ");
val = val.replace(',', " ");
Transform3D rMtarget = this->getTargetTransform();
Vector3D p_r = Vector3D::fromString(val);
Vector3D p_target = rMtarget.inv().coord(p_r);
this->setTargetLandmark(uid, p_target);
}
}
bool TToolbarEditor::getVis(int row, int col) {
QTableWidgetItem* item = active_actions_table->item(row, col);
if (item)
return item->checkState() != Qt::Unchecked;
return true;
}
void IgnoreListEditor::slotUpdateLocalIgnoreList()
{
ConfigFile cfgFile;
QString ignoreFile = cfgFile.excludeFile(ConfigFile::UserScope);
QFile ignores(ignoreFile);
if (ignores.open(QIODevice::WriteOnly)) {
for(int row = 0; row < ui->tableWidget->rowCount(); ++row) {
QTableWidgetItem *patternItem = ui->tableWidget->item(row, patternCol);
QTableWidgetItem *deletableItem = ui->tableWidget->item(row, deletableCol);
if (patternItem->flags() & Qt::ItemIsEnabled) {
QByteArray prepend;
if (deletableItem->checkState() == Qt::Checked) {
prepend = "]";
}
ignores.write(prepend+patternItem->text().toUtf8()+'\n');
}
}
// We need to force a remote discovery after a change of the ignore list.
// Otherwise we would not download the files/directories that are no longer
// ignored (because the remote etag did not change) (issue #3172)
foreach (Folder* folder, FolderMan::instance()->map()) {
folder->journalDb()->forceRemoteDiscoveryNextSync();
}
} else {
// ------------------------------------------------------------------------
void DicomParser::getSelectedSeries(DicomSeriesList & selectedSeries)
{
for(unsigned int i = 0; i < seriesAgain.size(); i++)
{
QTableWidgetItem * item = table->item(i,4);
if(item->checkState() == Qt::Checked)
selectedSeries.push_back(seriesAgain[i]);
}
}
bool tcStockSelectDialog::GetSelectedStockInfoList(tcStockInfoList &pStockInfoList)
{
int i;
for (i=0; i<tbl1->rowCount(); i++) {
QTableWidgetItem *item = tbl1->item(i, 0);
Q_ASSERT(item);
if (item->checkState() == Qt::Checked) {
tcStockInfo info = mViewStockInfoList[i];
pStockInfoList.append(info);
}
}
return true;
}
bool tAllChannelStatus::IsFavorite(const int focusRow)
{
QTableWidgetItem* widget = item(focusRow, FAV_COLUMN);
if (widget)
{
return(widget->checkState() == Qt::Checked);
}
else
{
return(false); //just do something for now
}
}
void StochasticProcessWidget::updateSelectAllRow(
int index) {
if (index == 3) {
return;
}
bool allChecked = true;
bool allUnchecked = true;
int columnCount = distGraphTable->columnCount();
for (int i = 0; i <= columnCount - 2; i++) {
QTableWidgetItem *item = distGraphTable->item(
index, i);
if (item) {
bool isChecked = item->checkState()
== Qt::Checked;
bool isPartiallyChecked =
item->checkState()
== Qt::PartiallyChecked;
allChecked = allChecked && isChecked
&& !isPartiallyChecked;
allUnchecked = allUnchecked && !isChecked
&& !isPartiallyChecked;
}
}
QTableWidgetItem
*selectAllItem = distGraphTable->item(
index, columnCount - 1);
if (selectAllItem) {
if (allChecked) {
selectAllItem->setCheckState(Qt::Checked);
} else if (allUnchecked) {
selectAllItem->setCheckState(Qt::Unchecked);
} else {
selectAllItem->setCheckState(Qt::PartiallyChecked);
}
}
}
void RoomsDialog::delButtonClicked()
{
int s = this->m_tableWidget->rowCount();
QList<int> ids = QList<int>();
for (int i = 0; i < s; ++i) {
QTableWidgetItem *item = this->m_tableWidget->item(i, 4);
if (item->checkState() == Qt::Checked) {
int id = this->m_tableWidget->item(i, 0)->text().toInt();
ids.append(id);
}
}
gdata->deleteRooms(ids);
}
void rtCathDataObject::tableCellChanged(int row, int col) {
// Is it one of the check boxes?
if(col == 0) {
QTableWidgetItem* item = m_cathGuiSetup.pointsTable->item(row, col);
QTableWidgetItem* itemID = m_cathGuiSetup.pointsTable->item(row, col+1);
if (!item || !itemID) return;
int id=0;
bool ok=false;
id = itemID->text().toInt(&ok);
if ( ok ) {
if (item->checkState()==Qt::Checked) {
item->setText("ON");
item->setCheckState(Qt::Checked);
// Get from the discard pile...
if(m_discardCoilList.contains(id)) {
m_coilList.insert(id, m_discardCoilList.take(id));
m_coilList[id].visible = true;
m_coilLocations.insert(m_coilList[id].locationID, id);
}
} else if (item->checkState()==Qt::Unchecked) {
item->setText("OFF");
item->setCheckState(Qt::Unchecked);
if (m_coilList.contains(id)) {
// Send to discard pile...
m_coilList[id].visible = false;
m_coilLocations.remove(m_coilList[id].locationID, id);
m_discardCoilList.insert(id, m_coilList.take(id));
}
}
Modified();
}
}
}
/* Called to save data to the configuration file. */
void SettingsPagePointDataLoading::slot_save()
{
QStringList files;
if( m_fileTable->item( 0, 0 )->checkState() == Qt::Checked )
{
// All files are selected.
files << "All";
}
else
{
// Store only checked file items.
for( int i = 1; i < m_fileTable->rowCount(); i++ )
{
QTableWidgetItem* item = m_fileTable->item( i, 0 );
if( item->checkState() == Qt::Checked )
{
files << item->text();
}
}
}
QStringList oldFiles = GeneralConfig::instance()->getOpenAipPoiFileList();
// save the new file list
GeneralConfig::instance()->setOpenAipPoiFileList( files );
// Check, if file list has been modified
if( oldFiles.size() != files.size() )
{
// List size is different, emit signal.
emit fileListChanged();
}
else
{
// The list size is equal, we have to check every single list element.
// Note that the lists are always sorted.
for( int i = 0; i < files.size(); i++ )
{
if( files.at(i) != oldFiles.at(i) )
{
// File names are different, emit signal.
emit fileListChanged();
break;
}
}
}
close();
}
void SporadicFrameEditDlg::OnButtonClickOk()
{
if ( 0 == nValidateValues() )
{
IFrame* pFrame;
LinFrameProps ouFrameProps;
ouFrameProps.m_eLinFrameType = eLinInvalidFrame;
if ( eEdit == m_ouMode )
{
pFrame = *m_pouFrame;
}
else
{
m_pLdfCluster->CreateElement(eFrameElement, (IElement**)&pFrame);
*m_pouFrame = pFrame;
}
if ( nullptr != pFrame )
{
pFrame->GetProperties(ouFrameProps);
//Frame Type
ouFrameProps.m_eLinFrameType = eLinSporadicFrame;
ouFrameProps.m_ouLINSporadicFrameProps.m_pouUnconditionalFrame.clear();
//Conditional Frames
int nRow = ui.tableFrames->rowCount();
IFrame* pouTempFrame;
for ( int i = 0 ; i < nRow; i++ )
{
QTableWidgetItem* pItem = ui.tableFrames->item(i, 0);
UID_ELEMENT uid = pItem->data(Qt::UserRole).value<UID_ELEMENT>();
if ( Qt::Checked == pItem->checkState() )
{
m_pLdfCluster->GetElement(eFrameElement, uid, (IElement**)&pouTempFrame);
if ( nullptr != pouTempFrame )
{
ouFrameProps.m_ouLINSporadicFrameProps.m_pouUnconditionalFrame[uid] = uid;
}
}
}
pFrame->SetProperties(ouFrameProps);
//Frame Name
pFrame->SetName(ui.editFrameName->text().toStdString());
}
LDFDatabaseManager::GetDatabaseManager()->setDocumentModified(true);
accept();
}
}
void
TransferFunctionManager::cellChanged(int row, int col)
{
if (!m_tfContainer) return;
if (col == 0)
{
QTableWidgetItem *wi;
wi = m_tableWidget->item(row, col);
SplineTransferFunction *tf = m_tfContainer->transferFunctionPtr(row);
tf->setName(wi->text());
}
else
{
QTableWidgetItem *wi;
wi = m_tableWidget->item(row, col);
m_tfContainer->setCheckState(row, col-1, wi->checkState());
bool flag = wi->checkState() == Qt::Checked;
emit checkStateChanged(row, col, flag);
qApp->processEvents();
}
}
/* Called to toggle the check box of the clicked table cell. */
void SettingsPagePointDataLoading::slot_toggleCheckBox( int row, int column )
{
QTableWidgetItem* item = m_fileTable->item( row, column );
if( row > 0 && m_fileTable->item( 0, 0 )->checkState() == Qt::Checked )
{
// All is checked, do not changed other items
return;
}
item->setCheckState( item->checkState() == Qt::Checked ? Qt::Unchecked : Qt::Checked );
if( row == 0 && column == 0 )
{
// First item was clicked. Change all other check items too.
Qt::CheckState newState = item->checkState();
// All other items are toggled too
for( int i = m_fileTable->rowCount() - 1; i > 0; i-- )
{
m_fileTable->item( i, 0 )->setCheckState( newState );
}
}
}
void
TagColorEditor::cellClicked(int row, int col)
{
int index = row*2 + col;
uchar *colors = Global::tagColors();
QTableWidgetItem *item = table->item(row, col);
if (item->checkState() == Qt::Checked)
colors[4*index+3] = 255;
else
colors[4*index+3] = 0;
emit tagSelected(index);
}
//-----------------------------------------------------------------------------
void ChannelSelectionDialog::on_channel_table__cellChanged (int row, int column)
{
if (column == VISIBLE_INDEX_)
{
if (!self_setting_)
{
self_setting_ = true;
QTableWidgetItem* item = ui_.channel_table_->item (row, column);
if (item->checkState() == Qt::Checked)
item->setCheckState (Qt::Unchecked);
else
item->setCheckState (Qt::Checked);
}
bool all_visible = true;
bool all_hidden = true;
for (int row_index = 0; row_index < ui_.channel_table_->rowCount(); ++row_index)
{
QTableWidgetItem* item = ui_.channel_table_->item (row_index, VISIBLE_INDEX_);
if (!item)
return;
if (item->checkState() == Qt::Checked)
{
all_hidden = false;
item->setForeground (VISIBLE_COLOR_);
}
else
{
all_visible = false;
item->setForeground (NOT_VISIBLE_COLOR_);
}
}
ui_.select_all_button_->setDisabled (all_visible);
ui_.unselect_all_button_->setDisabled (all_hidden);
ui_.button_box_->button (QDialogButtonBox::Ok)->setDisabled (all_hidden);
}
}
void
TransferFunctionManager::cellClicked(int row, int col)
{
if (!m_tfContainer) return;
QList<bool> on;
for (int i=0; i<m_tfContainer->maxSets(); i++)
{
QTableWidgetItem *wi;
wi = m_tableWidget->item(row, i+1);
bool flag = wi->checkState() == Qt::Checked;
on.append(flag);
}
emit changeTransferFunctionDisplay(row, on);
qApp->processEvents();
}
void QgsAttributeActionDialog::apply()
{
// Update the contents of mActions from the UI.
mActions->clearActions();
for ( int i = 0; i < attributeActionTable->rowCount(); ++i )
{
const QgsAction::ActionType type = ( QgsAction::ActionType ) actionType->findText( attributeActionTable->item( i, 0 )->text() );
const QString &name = attributeActionTable->item( i, 1 )->text();
const QString &action = attributeActionTable->item( i, 2 )->text();
if ( !name.isEmpty() && !action.isEmpty() )
{
QTableWidgetItem *item = attributeActionTable->item( i, 3 );
mActions->addAction( type, name, action, item->checkState() == Qt::Checked );
}
}
}
QVariant QgsValueRelationWidgetWrapper::value() const
{
QVariant v;
if ( mComboBox )
{
int cbxIdx = mComboBox->currentIndex();
if ( cbxIdx > -1 )
{
v = mComboBox->currentData();
}
}
if ( mTableWidget )
{
QStringList selection;
for ( int j = 0; j < mTableWidget->rowCount(); j++ )
{
for ( int i = 0; i < config( QStringLiteral( "NofColumns" ) ).toInt(); ++i )
{
QTableWidgetItem *item = mTableWidget->item( j, i );
if ( item )
{
if ( item->checkState() == Qt::Checked )
selection << item->data( Qt::UserRole ).toString();
}
}
}
v = selection.join( QStringLiteral( "," ) ).prepend( '{' ).append( '}' );
}
if ( mLineEdit )
{
Q_FOREACH ( const QgsValueRelationFieldFormatter::ValueRelationItem &item, mCache )
{
if ( item.value == mLineEdit->text() )
{
v = item.key;
break;
}
}
}
return v;
}
void CAllImgProcGUI::removeClicked()
{
for(int i=0; i<m_table->rowCount(); i++)
{
QTableWidgetItem *nameitem = m_table->item(i, 0);
if (0 == nameitem || nameitem->checkState() != Qt::Checked)
{
continue;
}
QTableWidgetItem *summitem = m_table->item(i, 1);
if (0 == summitem)
{
continue;
}
ImgProcTask task = imgProcTaskFromString(nameitem->text());
QString json = summitem->data(Qt::UserRole).toString();
switch(task)
{
case(IMGPROC_SMOOTH):
removeSmoothing(json);
break;
case(IMGPROC_MORPH):
removeMorph(json);
break;
case(IMGPROC_THRESHOLD):
removeThreshold(json);
break;
case(IMGPROC_GRADIENT):
removeGradient(json);
break;
case(IMGPROC_HOUGHLINES):
removeHoughLines(json);
break;
case(IMGPROC_CONVOLVE):
removeKernels(json);
break;
case(IMGPROC_UNKNOWN):
default:
continue;
}
}
emit updateProcessing();
updateTable();
redrawPreview();
}
ParameterList RenderWindow::getParameterList()
{
ParameterList plist;
QString name;
QVariant value;
QTableWidgetItem * ctItem = 0;
for(int r = 0; r < _table->rowCount(); r++) {
ctItem = _table->item(r, 0);
if(ctItem->checkState() == Qt::Checked) {
name = _table->item(r, 1)->text();
value = _params[name];
plist.append(name, value);
}
}
return plist;
}
//-----------------------------------------------------------------------------
void ChannelSelectionDialog::on_channel_table__cellClicked (int row, int column)
{
QTableWidgetItem* item = ui_.channel_table_->item (row, column);
if (column == LABEL_INDEX_)
{
self_setting_ = true;
if (item->checkState() == Qt::Checked)
item->setCheckState (Qt::Unchecked);
else
item->setCheckState (Qt::Checked);
}
else if (column == COLOR_INDEX_)
{
QColorDialog color_dialog (item->backgroundColor (), this);
if (color_dialog.exec () == QDialog::Accepted)
updateColor (row, color_dialog.selectedColor ());
}
self_setting_ = false;
}
void CDlgBulkRegister::ChangeCheckBoxStatus(QCheckBox *pChk)
{
int nIndex = pChk->whatsThis( ).toInt( );
for ( int nRow = 0; nRow < ui->tabRecord->rowCount( ); nRow++ ) {
QTableWidgetItem* pItem = ui->tabRecord->item( nRow, nIndex );
switch( pItem->checkState( ) )
{
case Qt::Checked :
pItem->setCheckState( Qt::Unchecked );
break;
case Qt::Unchecked :
pItem->setCheckState( Qt::Checked );
break;
}
}
}
//----------------------------------------------------------------------------
QStringList ctkDICOMServerNodeWidget::selectedServerNodes()const
{
Q_D(const ctkDICOMServerNodeWidget);
QStringList nodes;
const int count = d->NodeTable->rowCount();
for (int row = 0; row < count; ++row)
{
QTableWidgetItem* item = d->NodeTable->item(row, NameColumn);
if (item && item->checkState() == Qt::Checked)
{
nodes << item->text();
}
}
// If there are duplicates, serverNodeParameters(QString) will behave
// strangely
Q_ASSERT(nodes.removeDuplicates() == 0);
return nodes;
}
void
TagColorEditor::cellClicked(int row, int col)
{
if (row == 0 && col > 0)
return;
//int index = row*8 + col;
int index = 0;
if (row > 0) index = 1 + (row-1)*5 + col;
uchar *colors = Global::tagColors();
QTableWidgetItem *item = table->item(row, col);
if (item->checkState() == Qt::Checked)
colors[4*index+3] = 255;
else
colors[4*index+3] = 0;
emit tagSelected(index);
}
void CDlgSmsPhone::on_tableWidget_cellClicked(int row, int column)
{
if ( 4 != column ) { // 4 - column
return;
}
QTableWidgetItem* pItem = ui->tableWidget->item( row, column );
if ( NULL == pItem ) {
return;
}
Qt::CheckState state = pItem->checkState( );
if ( Qt::Unchecked == state ) {
state = Qt::Checked;
} else if ( Qt::Checked == state ) {
state = Qt::Unchecked;
}
pItem->setCheckState( state );
}
void LogSettingsPageWidget::sl_catItemStateChanged(QTableWidgetItem *item) {
if (tableWidget->row(item) == 0) {
return;
}
int column = tableWidget->column(item);
assert(column >= 1 && column <=LogLevel_NumLevels);
LogSettingsTopLineWidget* mainItem = qobject_cast<LogSettingsTopLineWidget*>(tableWidget->cellWidget(0, column));
int nEqual = 0;
for (int row = 1; row < tableWidget->rowCount(); row++) {
QTableWidgetItem* catItem = tableWidget->item(row, column);
assert(catItem!=NULL);
nEqual+=catItem->checkState() == item->checkState() ? 1 : 0;
}
if (nEqual == tableWidget->rowCount() - 1) {
mainItem->cb->setCheckState(item->checkState());
} else {
mainItem->cb->setCheckState(Qt::PartiallyChecked);
}
}
