//! [8]
void Window::showFiles(const QStringList &paths) {
for (const QString &filePath : paths) {
const QString toolTip = QDir::toNativeSeparators(filePath);
const QString relativePath =
QDir::toNativeSeparators(currentDir.relativeFilePath(filePath));
const qint64 size = QFileInfo(filePath).size();
QTableWidgetItem *fileNameItem = new QTableWidgetItem(relativePath);
fileNameItem->setData(absoluteFileNameRole, QVariant(filePath));
fileNameItem->setToolTip(toolTip);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem =
new QTableWidgetItem(QLocale().formattedDataSize(size));
sizeItem->setData(absoluteFileNameRole, QVariant(filePath));
sizeItem->setToolTip(toolTip);
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = filesTable->rowCount();
filesTable->insertRow(row);
filesTable->setItem(row, 0, fileNameItem);
filesTable->setItem(row, 1, sizeItem);
}
filesFoundLabel->setText(tr(
"%n file(s) found (Double click on a file to open it)", 0, paths.size()));
filesFoundLabel->setWordWrap(true);
}
//! [1]
void SubscriberDialog::subscriberChanged()
{
QStringList subPaths = subscriber->subPaths();
if (listWidget) {
listWidget->clear();
} else if (tableWidget) {
tableWidget->clearContents();
tableWidget->setRowCount(subPaths.count());
}
for (int i = 0; i < subPaths.count(); ++i) {
QVariant v = subscriber->value(subPaths.at(i));
if (listWidget) {
const QString itemTemplate("%1 (%2)\n%3");
QListWidgetItem *item =
new QListWidgetItem(itemTemplate.arg(subPaths.at(i), v.typeName(), v.toString()));
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
listWidget->addItem(item);
} else if (tableWidget) {
QTableWidgetItem *pathItem = new QTableWidgetItem(subPaths.at(i));
pathItem->setFlags(pathItem->flags() & ~Qt::ItemIsEditable);
QTableWidgetItem *valueItem = new QTableWidgetItem(v.toString());
valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
QTableWidgetItem *typeItem = new QTableWidgetItem(v.typeName());
typeItem->setFlags(typeItem->flags() & ~Qt::ItemIsEditable);
tableWidget->setItem(i, 0, pathItem);
tableWidget->setItem(i, 1, valueItem);
tableWidget->setItem(i, 2, typeItem);
}
}
}
static QTableWidget* createFilesTable(const QStringList &fileNames)
{
QTableWidget *table = new QTableWidget(0, 2);
table->setSelectionMode(QAbstractItemView::NoSelection);
QStringList labels({
QCoreApplication::translate("AddImageToResources","Filename"),
QCoreApplication::translate("AddImageToResources","Size")
});
table->setHorizontalHeaderLabels(labels);
table->horizontalHeader()->setSectionResizeMode(0, QHeaderView::Stretch);
table->verticalHeader()->hide();
table->setShowGrid(false);
for (const QString &filePath : fileNames) {
const QString toolTip = QDir::toNativeSeparators(filePath);
const QString fileName = QFileInfo(filePath).fileName();
const qint64 size = QFileInfo(filePath).size() / 1024;
QTableWidgetItem *fileNameItem = new QTableWidgetItem(fileName);
fileNameItem->setToolTip(toolTip);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem = new QTableWidgetItem(QString::number(size) + " KB");
sizeItem->setToolTip(toolTip);
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = table->rowCount();
table->insertRow(row);
table->setItem(row, 0, fileNameItem);
table->setItem(row, 1, sizeItem);
}
return table;
}
void AnswersWidget::setData(const QString & data, int idValue)
{
id = idValue;
ui->answersTableWidget->setRowCount(0);
QStringList rowSplitResults = data.split(';');
int rowIndex = 0;
for (QString rowSplitResult : rowSplitResults)
{
QStringList columnSplitResult = rowSplitResult.split(':');
if (columnSplitResult.count() == 2)
{
QTableWidgetItem * answerTableWidgetItem = new QTableWidgetItem(columnSplitResult[0]);
answerTableWidgetItem->setFlags(answerTableWidgetItem->flags() | Qt::ItemIsEditable);
QTableWidgetItem * correctTableWidgetItem = new QTableWidgetItem(columnSplitResult[1]);
correctTableWidgetItem->setFlags(answerTableWidgetItem->flags() | Qt::ItemIsEditable);
ui->answersTableWidget->insertRow(rowIndex);
ui->answersTableWidget->setItem(rowIndex, 0, answerTableWidgetItem);
ui->answersTableWidget->setItem(rowIndex, 1, correctTableWidgetItem);
rowIndex++;
}
}
}
void LandmarkBrowser::updateCategoryTable(const QList<QLandmarkCategory> &cats)
{
QLandmarkCategory cat;
QTableWidgetItem *item;
for ( int i =0; i < cats.count(); ++i) {
cat = cats.at(i);
categoryTable->insertRow(categoryTable->rowCount());
if(manager->isReadOnly(cat.categoryId())) {
item = new QTableWidgetItem(cat.name() + "(global)");
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
categoryTable->setItem(categoryTable->rowCount()-1,0, item);
} else {
item = new QTableWidgetItem(cat.name());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
categoryTable->setItem(categoryTable->rowCount()-1,0,item);
}
item = new QTableWidgetItem(cat.categoryId().localId());
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
categoryTable->setItem(categoryTable->rowCount()-1,1, item);
if (i %20)
qApp->processEvents();
}
}
void PresetController::addPreset(Preset *p){
p->setParent(this);
m_instanceNum++;
m_pList.append(p);
if(p->m_name == QString()){
p->m_name = tr("Preset ") + QString::number(m_instanceNum);
}
QTableWidgetItem *name = new QTableWidgetItem(p->m_name);
QTableWidgetItem *set = new QTableWidgetItem(tr("set"));
QTableWidgetItem *del = new QTableWidgetItem(tr("del"));
name->setToolTip(tr("Preset saved on ") + p->m_date.toString(tr("dd-MM-yyyy hh:mm:ss")));
set->setFlags(set->flags() & ~Qt::ItemIsEditable);
set->setTextAlignment(Qt::AlignCenter);
del->setFlags(del->flags() & ~Qt::ItemIsEditable);
del->setTextAlignment(Qt::AlignCenter);
int row = m_tw->rowCount();
m_tw->insertRow(row);
m_tw->setItem(row, 0, name);
m_tw->setItem(row, 1, set);
m_tw->setItem(row, 2, del);
GLOBAL_settingsChanged = true;
}
void jTransaction::setRow(QTableWidget* table, int row)
{
QTableWidgetItem * dateTableItem;
QTableWidgetItem * descTableItem;
QTableWidgetItem * catTableItem;
QTableWidgetItem * amountTableItem;
dateTableItem = new QTableWidgetItem();
dateTableItem->setFlags(dateTableItem->flags() ^ Qt::ItemIsEditable);
dateTableItem->setData(Qt::EditRole, mDate);
descTableItem = new QTableWidgetItem(mDescription);
descTableItem->setFlags(descTableItem->flags() ^ Qt::ItemIsEditable);
catTableItem = new QTableWidgetItem(mCategory);
catTableItem->setFlags(catTableItem->flags() ^ Qt::ItemIsEditable);
amountTableItem = new QTableWidgetItem(QLocale().toCurrencyString(mAmount));
amountTableItem->setFlags(amountTableItem->flags() ^ Qt::ItemIsEditable);
table->setItem(row,0, dateTableItem);
table->setItem(row,1, catTableItem);
table->setItem(row,2, descTableItem);
table->setItem(row,3, amountTableItem);
}
void Window::showFiles(const QStringList &files)
{
for (int i=0; i<files.size(); ++i)
{
QFile file(currentDir.absoluteFilePath(files[i]));
qint64 size = QFileInfo(file).size();
QTableWidgetItem *fileNameItem = new QTableWidgetItem(files[i]);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem = new QTableWidgetItem(tr("%1 KB")
.arg(int((size + 1023) / 1024)));
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = filesTable->rowCount();
filesTable->insertRow(row);
filesTable->setItem(row, 0, fileNameItem);
filesTable->setItem(row, 1, sizeItem);
}
filesFoundLabel->setText(tr("%1 file(s) found")
.arg(files.size())
+ " Double click to open it");
}
/*! @brief Takes in an action and adds it to the queue.
This function parses the passed action and displays the appropriate information in the table.
It also stores the action as data in the QTableWidgetItem in the first column.
This is done using the function setData().
This function takes in an int and a QVariant.
The int represents a role - this is basically an index into an array or a key into a hashtable.
The role used here is predefined within Qt - Qt::UserRole.
This role is specifically set aside by Qt for the user to use - it should be empty unless the user puts something in it.
The QVariant is the data to be stored. QVariants can store any type of data - even structs!
In this case, an action struct is being stored using the function setValue().
After storing the action into the QVariant, the QVariant can be stored in the QTableWidgetItem using setData().
To extract the data from the QTableWidgetItem, simply call the function data().
This function takes in an int representing a role. To retrieve the data store here, pass it Qt::UserRole.
The function will return a QVariant. The QVariant can be cast into whatever data type is stored within it using the value() function.
In this case, of course, the data type is the struct Action. The form for the function should look like this:
Action act = qvariant.value<Action>();
"Action" here can be replaced with an arbitrary data type.
*/
void Queue::addActionToQueue(Action action) {
QVariant v;
v.setValue(action);
QTableWidgetItem* act = new QTableWidgetItem(0);
act->setData(Qt::UserRole, v);
act->setFlags(act->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem* span = new QTableWidgetItem(0);
span->setFlags(span->flags() ^ Qt::ItemIsEditable);
span->setTextAlignment(Qt::AlignHCenter);
int index = action.queueIndex;
if (action.typ != INITIALIZE || rowCount() == 0) {
insertRow(index);
setRowHeight(index, 20);
}
setItem(index, 0, act);
setItem(index, 1, span);
for (int i=0; i < 5; i++) {
QTableWidgetItem* item = new QTableWidgetItem(0);
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
setItem(index, i + 2, item);
}
updateQueue(index, rowCount());
}
void QgsAuthMethodPlugins::populateTable()
{
QgsAuthMethodsMap authmethods( QgsAuthManager::instance()->authMethodsMap() );
int i = 0;
for ( QgsAuthMethodsMap::const_iterator it = authmethods.constBegin(); it != authmethods.constEnd(); ++it, i++ )
{
QgsAuthMethod *authmethod( it.value() );
if ( !authmethod )
{
continue;
}
QTableWidgetItem *twi = new QTableWidgetItem( authmethod->key() );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
tblAuthPlugins->setItem( i, 0, twi );
twi = new QTableWidgetItem( authmethod->displayDescription() );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
tblAuthPlugins->setItem( i, 1, twi );
twi = new QTableWidgetItem( authmethod->supportedDataProviders().join( ", " ) );
twi->setFlags( twi->flags() & ~Qt::ItemIsEditable );
tblAuthPlugins->setItem( i, 2, twi );
}
tblAuthPlugins->sortItems( 0 );
}
//! [8]
void Window::showFiles(const QStringList &files)
{
for (int i = 0; i < files.size(); ++i) {
QFile file(currentDir.absoluteFilePath(files[i]));
qint64 size = QFileInfo(file).size();
QTableWidgetItem *fileNameItem = new QTableWidgetItem(files[i]);
fileNameItem->setFlags(fileNameItem->flags() ^ Qt::ItemIsEditable);
QTableWidgetItem *sizeItem = new QTableWidgetItem(tr("%1 KB")
.arg(int((size + 1023) / 1024)));
sizeItem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
sizeItem->setFlags(sizeItem->flags() ^ Qt::ItemIsEditable);
int row = filesTable->rowCount();
filesTable->insertRow(row);
filesTable->setItem(row, 0, fileNameItem);
filesTable->setItem(row, 1, sizeItem);
}
filesFoundLabel->setText(tr("%1 file(s) found").arg(files.size()) +
#if defined(Q_OS_SYMBIAN) || defined(Q_WS_MAEMO_5)
(" (Select file to open it)"));
#else
(" (Double click on a file to open it)"));
#endif
filesFoundLabel->setWordWrap(true);
}
void Pasajeros::Recargar()
{
for(int i = 0; i < ui->TablaPasajeros->rowCount();){
delete ui->TablaPasajeros->item(i,0);
delete ui->TablaPasajeros->item(i,1);
delete ui->TablaPasajeros->item(i,2);
ui->TablaPasajeros->removeRow(i);
}
vector<Pasajero>::iterator pasajeros = (*it).Pasajeros.begin();
while(pasajeros != (*it).Pasajeros.end()){
QTableWidgetItem* Nombre = new QTableWidgetItem();
QTableWidgetItem* Apellido = new QTableWidgetItem();
QTableWidgetItem* Asiento = new QTableWidgetItem();
Nombre->setText(QString::fromStdString((*pasajeros).getNombre()));
Apellido->setText(QString::fromStdString((*pasajeros).getApellido()));
Asiento->setText(QString::fromStdString((*pasajeros).getAsiento()));
Nombre->setFlags(Nombre->flags() ^ Qt::ItemIsEditable);
Apellido->setFlags(Apellido->flags() ^ Qt::ItemIsEditable);
Asiento->setFlags(Asiento->flags() ^ Qt::ItemIsEditable);
Nombre->setTextAlignment(Qt::AlignHCenter);
Apellido->setTextAlignment(Qt::AlignHCenter);
Asiento->setTextAlignment(Qt::AlignHCenter);
const int i = ui->TablaPasajeros->rowCount();
ui->TablaPasajeros->insertRow(i);
ui->TablaPasajeros->setItem(i,0,Nombre);
ui->TablaPasajeros->setItem(i,1,Apellido);
ui->TablaPasajeros->setItem(i,2,Asiento);
pasajeros++;
}
}
CurrencyPane::CurrencyPane(QWidget *parent) :
QWidget(parent),
ui(new Ui::CurrencyPane)
{
ui->setupUi(this);
currency = QStringList({"Scroll of Wisdom",
"Portal Scroll",
"Armourer's Scrap",
"Blacksmith's Whetstone",
"Glassblower's Bauble",
"Cartographer's Chisel",
"Gemcutter's Prism",
"Jeweller's Orb",
"Chromatic Orb",
"Orb of Fusing",
"Orb of Transmutation",
"Orb of Chance",
"Orb of Alchemy",
"Regal Orb",
"Orb of Augmentation",
"Exalted Orb",
"Orb of Alteration",
"Chaos Orb",
"Blessed Orb",
"Divine Orb",
"Orb of Scouring",
"Mirror of Kalandra",
"Orb of Regret",
"Vaal Orb",
"Eternal Orb"});
ui->currencyTable->setTabKeyNavigation(true);
ui->currencyTable->verticalHeader()->show();
ui->currencyTable->blockSignals(true);
for (QString currencyItem : currency) {
int row = ui->currencyTable->rowCount();
ui->currencyTable->insertRow(row);
QTableWidgetItem* item = new QTableWidgetItem(currencyItem);
ui->currencyTable->setVerticalHeaderItem(row, item);
item = new QTableWidgetItem("0");
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui->currencyTable->setItem(row, 0, item);
ui->currencyTable->setItem(row, 1, new QTableWidgetItem("0"));
// Generate cell widget!
RatioCell* cell = new RatioCell(ui->currencyTable);
ui->currencyTable->setCellWidget(row, 1, cell);
connect(cell, &RatioCell::editingFinished, this, &CurrencyPane::UpdateItemChaosValues);
item = new QTableWidgetItem("0");
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
ui->currencyTable->setItem(row, 2, item);
}
ui->currencyTable->blockSignals(false);
ui->currencyTable->update();
}
// ------------------------------------------------------------------------
QWidget * DicomParser::createTable()
{
// create the table and the headers
table = new QTableWidget(this);
QStringList headers;
headers << "Series Name";
headers << "Number";
headers << "Number";
headers << "Study";
headers << "Include";
table->setRowCount(this->series.size());
table->setColumnCount(5);
table->setHorizontalHeaderLabels(headers);
table->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
table->setSelectionMode(QAbstractItemView::SingleSelection);
table->setSelectionBehavior(QAbstractItemView::SelectRows);
table->setShowGrid(false);
double start = posString(seriesAgain.front().images.front());
double last = 0.0;
for(unsigned int i = 0; i < seriesAgain.size(); i++)
{
QString name = QString::fromStdString(seriesAgain[i].description);
QTableWidgetItem * item = new QTableWidgetItem(name);
item->setFlags(item->flags()^Qt::ItemIsEditable);
table->setItem(i,0,item);
double pos = posString(seriesAgain[i].images[0]);
double diff = pos - start;
double comp = pos - last;
last = pos;
std::stringstream ssp;
ssp << diff << " - " << comp;
QTableWidgetItem * number = new QTableWidgetItem(QString::number(seriesAgain[i].images[0].seriesNumber));
QTableWidgetItem * num = new QTableWidgetItem(QString::fromStdString(ssp.str()));
QTableWidgetItem * study = new QTableWidgetItem(QString::fromStdString(seriesAgain[i].images[0].studyUID));
num->setFlags(item->flags());
table->setItem(i,3, study);
table->setItem(i,2,num);
table->setItem(i,1,number);
QTableWidgetItem * check = new QTableWidgetItem;
check->setCheckState(Qt::Unchecked);
check->setFlags(item->flags() ^ Qt::ItemIsUserCheckable);
table->setItem(i,4, check);
}
table->resizeColumnToContents(3);
return table;
}
// Function to populate the data tree
void US_XpnRunAuc::populate_list()
{
QFont tw_font( US_Widgets::fixedFont().family(),
US_GuiSettings::fontSize() );
QFontMetrics* fm = new QFontMetrics( tw_font );
int rowht = fm->height() + 2;
tw->setFont ( tw_font );
tw->setPalette( US_GuiSettings::editColor() );
tw->setRowCount( runInfo.count() );
QStringList headers;
headers << tr( "Run" ) << tr( "Date" ) << tr( "Triples Count" );
tw->setHorizontalHeaderLabels( headers );
tw->verticalHeader()->hide();
tw->setShowGrid( false );
tw->setSelectionBehavior( QAbstractItemView::SelectRows );
tw->setMinimumWidth ( 100 );
tw->setMinimumHeight( 100 );
tw->setColumnWidth( 0, 250 );
tw->setColumnWidth( 1, 150 );
tw->setColumnWidth( 2, 50 );
tw->setSortingEnabled( false );
tw->clearContents();
// Now load the table, marking each as not-editable
for ( int ii = 0; ii < runInfo.size(); ii++ )
{
QTableWidgetItem* item;
RunInfo rr = runInfo[ ii ];
QString tripk = QString().sprintf( "%5d", rr.ntriple );
item = new QTableWidgetItem( rr.runID );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 0, item );
item = new QTableWidgetItem( rr.date );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 1, item );
item = new QTableWidgetItem( tripk );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 2, item );
//qDebug() << "setItems ii" << ii << "ID date runID label"
// << rr.ID << rr.date << rr.runID << rr.label;
tw ->setRowHeight( ii, rowht );
}
tw->setSortingEnabled( true );
tw->sortByColumn( 1, Qt::DescendingOrder );
tw->resizeColumnsToContents();
tw->adjustSize();
tw->resize( size().width() - 4, tw->size().height() );
qApp->processEvents();
}
void PropertiesWidget::updateDisplayedProperties()
{
tableWidget->clear();
_propNames.clear();
tableWidget->setColumnCount(2);
QStringList horizontalHeaders;
horizontalHeaders.append("Name");
horizontalHeaders.append("Value");
tableWidget->setHorizontalHeaderLabels(horizontalHeaders);
tableWidget->verticalHeader()->hide();
PropertyMap* properties = _properties;
if (! properties)
return;
tableWidget->setRowCount(properties->size());
int r = 0;
for (PropertyMap::PropertyMapIterator it = properties->begin(); it != properties->end(); ++it, ++r) {
QTableWidgetItem* textItem = new QTableWidgetItem;
textItem->setText(QString::fromLocal8Bit(humanReadablePropName(it->first).c_str()));
textItem->setFlags(textItem->flags() & ~Qt::ItemIsEditable);
tableWidget->setItem(r, 0, textItem);
_propNames.push_back(it->first);
if (dynamic_cast<Property<bool>*>(it->second)) {
Property<bool>* prop = static_cast<Property<bool>*>(it->second);
QTableWidgetItem* checkItem = new QTableWidgetItem;
checkItem->setText("enabled");
checkItem->setFlags(checkItem->flags() | Qt::ItemIsUserCheckable);
if (prop->value())
checkItem->setCheckState(Qt::Checked);
else
checkItem->setCheckState(Qt::Unchecked);
tableWidget->setItem(r, 1, checkItem);
} else {
QLineEdit* editor = new QLineEdit(tableWidget);
editor->setText(QString::fromLocal8Bit(it->second->toString().c_str()));
if (dynamic_cast<Property<int>*>(it->second)) {
editor->setValidator(new QIntValidator(editor));
}
else if (dynamic_cast<Property<float>*>(it->second)) {
editor->setValidator(new QDoubleValidator(editor));
}
else if (dynamic_cast<Property<double>*>(it->second)) {
editor->setValidator(new QDoubleValidator(editor));
}
tableWidget->setCellWidget(r, 1, editor);
}
}
tableWidget->resizeColumnToContents(0);
}
void save_data_list_dialog::UpdateList()
{
m_list->clearContents();
m_list->setRowCount((int)m_save_entries.size());
QVariantMap currNotes = m_gui_settings->GetValue(gui::m_saveNotes).toMap();
int row = 0;
for (const SaveDataEntry& entry: m_save_entries)
{
QString title = qstr(entry.title);
QString subtitle = qstr(entry.subtitle);
QString dirName = qstr(entry.dirName);
QTableWidgetItem* titleItem = new QTableWidgetItem(title);
titleItem->setData(Qt::UserRole, row); // For sorting to work properly
titleItem->setFlags(titleItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 0, titleItem);
QTableWidgetItem* subtitleItem = new QTableWidgetItem(subtitle);
subtitleItem->setFlags(subtitleItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 1, subtitleItem);
QTableWidgetItem* dirNameItem = new QTableWidgetItem(dirName);
dirNameItem->setFlags(dirNameItem->flags() & ~Qt::ItemIsEditable);
m_list->setItem(row, 2, dirNameItem);
QTableWidgetItem* noteItem = new QTableWidgetItem();
noteItem->setFlags(noteItem->flags() | Qt::ItemIsEditable);
if (currNotes.contains(dirName))
{
noteItem->setText(currNotes[dirName].toString());
}
m_list->setItem(row, 3, noteItem);
++row;
}
m_list->horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
m_list->verticalHeader()->resizeSections(QHeaderView::ResizeToContents);
QSize tableSize = QSize
(
m_list->verticalHeader()->width() + m_list->horizontalHeader()->length() + m_list->frameWidth() * 2,
m_list->horizontalHeader()->height() + m_list->verticalHeader()->length() + m_list->frameWidth() * 2
);
QSize preferredSize = minimumSize().expandedTo(sizeHint() - m_list->sizeHint() + tableSize);
QSize maxSize = QSize(preferredSize.width(), static_cast<int>(QApplication::desktop()->screenGeometry().height()*.6));
resize(preferredSize.boundedTo(maxSize));
}
void FormOptimization::update_plots() {
bool have_data = false;
bool have_peaks = false;
for (auto &q: current_spectra_.by_type("1D")) {
Qpx::Spectrum::Metadata md;
if (q)
md = q->metadata();
if (md.total_count > 0) {
have_data = true;
fitter_opt_.setData(q);
}
}
if (have_data) {
have_peaks = find_peaks();
int current_spec = spectra_.size() - 1;
spectra_[current_spec] = fitter_opt_;
setting_fwhm_[current_spec] = peaks_[current_spec].fwhm_hyp;
ui->tableResults->setRowCount(peaks_.size());
QTableWidgetItem *st = new QTableWidgetItem(QString::number(setting_values_[current_spec]));
st->setFlags(st->flags() ^ Qt::ItemIsEditable);
ui->tableResults->setItem(current_spec, 0, st);
QTableWidgetItem *en = new QTableWidgetItem(QString::number(peaks_[current_spec].energy));
en->setFlags(en->flags() ^ Qt::ItemIsEditable);
ui->tableResults->setItem(current_spec, 1, en);
QTableWidgetItem *fw = new QTableWidgetItem(QString::number(peaks_[current_spec].fwhm_hyp));
fw->setFlags(fw->flags() ^ Qt::ItemIsEditable);
ui->tableResults->setItem(current_spec, 2, fw);
QTableWidgetItem *area = new QTableWidgetItem(QString::number(peaks_[current_spec].area_best.val));
area->setFlags(area->flags() ^ Qt::ItemIsEditable);
ui->tableResults->setItem(current_spec, 3, area);
QTableWidgetItem *err = new QTableWidgetItem(QString::number(peaks_[current_spec].sum4_.peak_area.err()));
err->setFlags(err->flags() ^ Qt::ItemIsEditable);
ui->tableResults->setItem(current_spec, 4, err);
}
if (ui->plotSpectrum->isVisible())
ui->plotSpectrum->update_spectrum();
if (have_peaks && !peaks_.empty() && (peaks_.back().sum4_.peak_area.err() < ui->doubleError->value()))
interruptor_.store(true);
resultChosen();
}
void GraphicEQFilterGUI::setFreqEditable(bool editable)
{
ui->tableWidget->blockSignals(true);
for (int i = 0; i < ui->tableWidget->rowCount(); i++)
{
QTableWidgetItem* item = ui->tableWidget->item(i, 0);
if (editable)
item->setFlags(item->flags() | Qt::ItemIsEditable | Qt::ItemIsEnabled);
else
item->setFlags(item->flags() & ~(Qt::ItemIsEditable | Qt::ItemIsEnabled));
}
ui->tableWidget->blockSignals(false);
}
void AnswersWidget::on_AddAnswerPushButton_clicked()
{
int rowIndex = ui->answersTableWidget->rowCount();
QTableWidgetItem * answerTableWidgetItem = new QTableWidgetItem("Answer");
answerTableWidgetItem->setFlags(answerTableWidgetItem->flags() | Qt::ItemIsEditable | Qt::ItemIsSelectable);
QTableWidgetItem * correctTableWidgetItem = new QTableWidgetItem("true");
correctTableWidgetItem->setFlags(answerTableWidgetItem->flags() | Qt::ItemIsEditable | Qt::ItemIsSelectable);
ui->answersTableWidget->insertRow(rowIndex);
ui->answersTableWidget->setItem(rowIndex, 0, answerTableWidgetItem);
ui->answersTableWidget->setItem(rowIndex, 1, correctTableWidgetItem);
}
void QgsGrassEdit::setAttributeTable( int field )
{
mAttributeTable->setRowCount( 0 );
QString *key = mProvider->key( field );
if ( !key->isEmpty() ) // Database link defined
{
QVector<QgsField> *cols = mProvider->columns( field );
mAttributeTable->setRowCount( cols->size() );
for ( int c = 0; c < cols->size(); c++ )
{
QgsField col = ( *cols )[c];
QTableWidgetItem *ti;
ti = new QTableWidgetItem( col.name() );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 0, ti );
ti = new QTableWidgetItem( col.typeName() );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 1, ti );
QString str;
str.sprintf( "%d", col.length() );
ti = new QTableWidgetItem( str );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( c, 2, ti );
}
}
else
{
mAttributeTable->setRowCount( 1 );
QTableWidgetItem *ti;
ti = new QTableWidgetItem( "cat" );
mAttributeTable->setItem( 0, 0, ti );
ti = new QTableWidgetItem( "integer" );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( 0, 1, ti );
ti = new QTableWidgetItem( "" );
ti->setFlags( ti->flags() & ~Qt::ItemIsEnabled );
mAttributeTable->setItem( 0, 2, ti );
}
}
// Function to limit table data shown based on search criteria
void US_XpnRunAuc::limit_data( const QString& sfilt )
{
bool have_search = ! sfilt.isEmpty();
qDebug() << "LimData: sfilt" << sfilt << "have_search" << have_search;
QFont tw_font( US_Widgets::fixedFont().family(),
US_GuiSettings::fontSize() );
QFontMetrics* fm = new QFontMetrics( tw_font );
int rowht = fm->height() + 2;
tw->clearContents();
tw->setSortingEnabled( false );
qDebug() << "LimData: runInfo size" << runInfo.size();
for ( int ii = 0; ii < runInfo.size(); ii++ )
{
QTableWidgetItem* item;
RunInfo rr = runInfo[ ii ];
QString tripk = QString().sprintf( "%5d", rr.ntriple );
qDebug() << "LimData: ii" << ii << "runID" << rr.runID;
// Skip item if search text exists and runID does not contain it
if ( have_search &&
! rr.runID.contains( sfilt, Qt::CaseInsensitive ) )
continue;
item = new QTableWidgetItem( rr.runID );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 0, item );
item = new QTableWidgetItem( rr.date );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 1, item );
item = new QTableWidgetItem( tripk );
item->setFlags( item->flags() ^ Qt::ItemIsEditable );
tw ->setItem( ii, 2, item );
qDebug() << "setItems ii" << ii << "date runID dbId"
<< rr.date << rr.runID << rr.dbId;
tw ->setRowHeight( ii, rowht );
}
tw->setSortingEnabled( true );
tw->sortByColumn( 1, Qt::DescendingOrder );
tw->resizeColumnsToContents();
tw->adjustSize();
// tw->update();
// update();
tw->resize( size().width() - 4, tw->size().height() );
qApp->processEvents();
}
/**
Cleans and readds entries to table widget in UI.
*/
int game_list_frame::PopulateGameList()
{
int result = -1;
std::string selected_item = CurrentSelectionIconPath();
// Hack to delete everything without removing the headers.
gameList->setRowCount(0);
gameList->setRowCount(m_game_data.size());
auto l_GetItem = [](const std::string& text)
{
QTableWidgetItem* curr = new QTableWidgetItem;
curr->setFlags(curr->flags() & ~Qt::ItemIsEditable);
curr->setText(qstr(text));
return curr;
};
int row = 0;
for (GUI_GameInfo game : m_game_data)
{
if (SearchMatchesApp(game.info.name, game.info.serial) == false)
{
// We aren't showing this entry. Decrement row count to avoid empty entries at end.
gameList->setRowCount(gameList->rowCount() - 1);
continue;
}
// Icon
QTableWidgetItem* iconItem = new QTableWidgetItem;
iconItem->setFlags(iconItem->flags() & ~Qt::ItemIsEditable);
iconItem->setData(Qt::DecorationRole, game.pxmap);
iconItem->setData(Qt::UserRole, row);
gameList->setItem(row, 0, iconItem);
gameList->setItem(row, 1, l_GetItem(game.info.name));
gameList->setItem(row, 2, l_GetItem(game.info.serial));
gameList->setItem(row, 3, l_GetItem(game.info.fw));
gameList->setItem(row, 4, l_GetItem(game.info.app_ver));
gameList->setItem(row, 5, l_GetItem(game.info.category));
gameList->setItem(row, 6, l_GetItem(game.info.root));
if (selected_item == game.info.icon_path) result = row;
row++;
}
return result;
}
void PointListWidget::addPoint(const QPoint &point)
{
int row = ui->list->rowCount();
ui->list->setRowCount(row + 1);
QTableWidgetItem *item = new QTableWidgetItem(QString::number(point.x()));
item->setFlags(item->flags() | Qt::ItemIsEditable);
ui->list->setItem(row, 0, item);
item = new QTableWidgetItem(QString::number(point.y()));
item->setFlags(item->flags() | Qt::ItemIsEditable);
ui->list->setItem(row, 1, item);
updateClearStatus();
}
void StudentMainWidget::populateTableData()
{
QString tempString;
Lesson tempLesson;
QTableWidgetItem *item;
lessons = LessonsDBController::getDB();
while (mainTable->rowCount() < lessons->getLessons().size())
{
mainTable->insertRow(mainTable->rowCount());
}
while (mainTable->rowCount() > lessons->getLessons().size())
{
mainTable->removeRow(mainTable->rowCount()-1);
}
for (int i=0; i<lessons->getLessons().size(); i++)
{
tempLesson = lessons->getLessons().at(i);
tempString = tempLesson.getTopic();
item = new QTableWidgetItem(tr(tempString.toStdString().c_str()));
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
mainTable->setItem(i,0,item);
tempString = tempLesson.getLesson();
GridButton *button = new GridButton(this);
button->setText(tr(tempString.toStdString().c_str()));
button->setIndex(i);
button->setEnabled(true);
connect(button,SIGNAL(leftClicked()),this,SLOT(transition()));
connect(button,SIGNAL(entered()),this,SLOT(changeToHand()));
connect(button,SIGNAL(left()),this,SLOT(changeToCursor()));
mainTable->setCellWidget(i,1,button);
int maxMarks = tempLesson.getMaxMarks();
tempString = "0";
tempString += "/";
tempString += QString::number(maxMarks);
item = new QTableWidgetItem(tr(tempString.toStdString().c_str()));
item->setFlags(item->flags() ^ Qt::ItemIsEditable);
mainTable->setItem(i,2,item);
}
}
void AppDockWidget::loadThreadCoreData(QString)
{
QDir dir;
QString filePath = mainwindow->GetCurrentWorkDir();
QString fileString = filePath + "/test/info_threadcore.txt";
QFile inputFile(fileString);
inputFile.open(QIODevice::ReadOnly);
if (inputFile.size() != 0) {
QTextStream in(&inputFile);
int i = 0;
QTableWidgetItem *item;
while (!in.atEnd()) {
QString line = in.readLine();
QStringList lineList = line.split(',');
item = new QTableWidgetItem(
lineList[0] + "(" + lineList[1].split(" ")[1] + ")");
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
ui.threadcoreTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem(lineList[2]);
item->setFlags(item->flags() & ~Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
ui.threadcoreTableWidget->setItem(i, 1, item);
item = new QTableWidgetItem(lineList[3]);
item->setFlags(Qt::ItemIsEditable | Qt::ItemIsEnabled);
item->setTextAlignment(Qt::AlignHCenter);
ui.threadcoreTableWidget->setItem(i, 2, item);
bandComBox[i] = new QComboBox();
bandComBox[i]->addItem(lineList[4]);
i++;
}
for (int j = 0; j < i; j++) {
for (int k = 0; k < i; k++) {
bandComBox[j]->addItem("Core " + QString::number(k, 10));
}
bandComBox[j]->setObjectName(QString::number(j, 10));
ui.threadcoreTableWidget->setCellWidget(j, 3, bandComBox[j]);
connect (bandComBox[j], SIGNAL(currentIndexChanged (int)), this,
SLOT(sendBandCMD(int)));
}
} else
QTableWidget* StatusViewer::prepareTable(int rows, int cols) {
QTableWidget* table = new QTableWidget(this);
table->setColumnCount(cols);
table->setRowCount(rows);
table->setSelectionBehavior(QAbstractItemView::SelectRows);
table->setAttribute(Qt::WA_MacShowFocusRect, 0);
table->setShowGrid(false);
table->setAlternatingRowColors(true);
table->setSortingEnabled(false);
for (int c = 0; c < cols; ++c) {
table->horizontalHeader()->setSectionResizeMode(c, QHeaderView::Stretch);
}
for(int row=0; row<rows; ++row) {
for(int col=0; col<cols; ++col){
QTableWidgetItem* tableItem = new QTableWidgetItem();
tableItem->setFlags(tableItem->flags() ^ Qt::ItemIsEditable);
tableItem->setTextAlignment(Qt::AlignRight);
tableItem->setText("--");
table->setItem(row, col, tableItem);
}
}
return table;
}
/** Insert a row with a checkbox with folder's name and the number of files in this folder. */
void QuickStart::insertRow(const QFileInfo &fileInfo, const int & musicFileNumber)
{
// A subfolder is displayed with its number of files on the right
QTableWidgetItem *checkBox = new QTableWidgetItem;
checkBox->setFlags(checkBox->flags() | Qt::ItemIsUserCheckable);
checkBox->setCheckState(Qt::Checked);
QTableWidgetItem *musicSubFolderName = new QTableWidgetItem(QFileIconProvider().icon(fileInfo), fileInfo.baseName());
musicSubFolderName->setData(Qt::UserRole, fileInfo.absoluteFilePath());
QTableWidgetItem *musicSubFolderCount;
if (musicFileNumber == 0) {
musicSubFolderCount = new QTableWidgetItem(tr("empty folder"));
checkBox->setCheckState(Qt::Unchecked);
} else {
musicSubFolderCount = new QTableWidgetItem(tr("%n elements", "", musicFileNumber));
}
musicSubFolderCount->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
int rowCount = quickStartTableWidget->rowCount();
quickStartTableWidget->insertRow(rowCount);
quickStartTableWidget->setItem(rowCount, 0, checkBox);
quickStartTableWidget->setItem(rowCount, 1, musicSubFolderName);
quickStartTableWidget->setItem(rowCount, 2, musicSubFolderCount);
_totalMusicFiles += musicFileNumber;
}
QuickStart::QuickStart(QWidget *parent) :
QWidget(parent), _totalMusicFiles(0), _worker(NULL), _qsse(NULL)
{
setupUi(this);
QStringList musicLocations = QStandardPaths::standardLocations(QStandardPaths::MusicLocation);
if (musicLocations.isEmpty()) {
defaultFolderGroupBox->setVisible(false);
orLabel->setVisible(false);
} else {
defaultFolderTableWidget->setItemDelegate(new NoFocusItemDelegate(this));
defaultFolderTableWidget->insertRow(0);
QTableWidgetItem *checkBox = new QTableWidgetItem;
checkBox->setFlags(checkBox->flags() | Qt::ItemIsUserCheckable);
defaultFolderTableWidget->setItem(0, 0, checkBox);
QString musicLocation = musicLocations.first();
defaultFolderTableWidget->setItem(0, 1, new QTableWidgetItem(QFileIconProvider().icon(musicLocation), QDir::toNativeSeparators(musicLocation)));
connect(defaultFolderTableWidget, &QTableWidget::itemClicked, this, [=](QTableWidgetItem *i) {
if (i->column() != 0) {
if (defaultFolderTableWidget->item(0, 0)->checkState() == Qt::Checked) {
defaultFolderTableWidget->item(0, 0)->setCheckState(Qt::Unchecked);
} else {
defaultFolderTableWidget->item(0, 0)->setCheckState(Qt::Checked);
}
}
defaultFolderApplyButton->setEnabled(defaultFolderTableWidget->item(0, 0)->checkState() == Qt::Checked);
});
}
quickStartTableWidget->setItemDelegate(new NoFocusItemDelegate(this));
connect(quickStartTableWidget, &QTableWidget::itemClicked, this, &QuickStart::checkRow);
this->installEventFilter(this);
}
void QMathMLFileViewer::showFiles(const QStringList &files)
{
const int base = 10;
int maxValue = (int) (files.size() / base);
QProgressDialog progress("Showing files...", "Cancel", 0, maxValue, this);
progress.setWindowModality(Qt::WindowModal);
progress.setMinimumDuration(500);
for( int i = 0; i < files.size(); i++ )
{
if( i % base == 0 )
progress.setValue( i / 10 );
if( progress.wasCanceled() )
break;
QString filePath = m_currentDir.absoluteFilePath(files[i]);
QFile file( filePath );
QDateTime fileDate = QFileInfo( file ).lastModified();
QTableWidgetItem *fileNameItem = new QTableWidgetItem( files[i] );
fileNameItem->setFlags( fileNameItem->flags() ^ Qt::ItemIsEditable );
//QTableWidgetItem *fileDateItem = new QTableWidgetItem( fileDate.toString(Qt::SystemLocaleShortDate) );
//fileDateItem->setTextAlignment( Qt::AlignRight | Qt::AlignVCenter );
//fileDateItem->setFlags( fileDateItem->flags() ^ Qt::ItemIsEditable );
int row = filesTable->rowCount();
filesTable->insertRow( row );
filesTable->setItem( row, 0, fileNameItem );
//filesTable->setItem( row, 1, fileDateItem );
}
progress.setValue( maxValue );
}
