void KernelTable::setCenter(int row, int column)
{
if (row <= 0)
row = 1;
if (row > getRows())
row = getRows();
if (column <= 0)
column = 1;
if (column > getColumns())
column = getColumns();
centerRowBox->setValue(row);
centerColumnBox->setValue(column);
QTableWidgetItem *item;
for (int i = 0; i < getRows(); ++i)
for (int j = 0; j < getColumns(); ++j) {
item = tableWidget->item(i, j);
if (item == 0) {
item = new QTableWidgetItem("0.0");
tableWidget->setItem(i, j, item);
}
if (i + 1 == row && j + 1 == column)
item->setBackground(QBrush(Qt::gray));
else
item->setBackground(QBrush(Qt::white));
}
}
void AssociationsDialog::updateTable(int index)
{
Table *t = findTable(index);
if (!t)
return;
if (active_table != t){
active_table = t;
tableCaptionLabel->setText(t->objectName());
table->clearContents();
table->setRowCount(t->numCols());
QStringList colNames = t->colNames();
for (int i=0; i<table->rowCount(); i++ ){
QTableWidgetItem *cell = new QTableWidgetItem(colNames[i].replace(",", "."));
cell->setBackground (QBrush(Qt::lightGray));
cell->setFlags (Qt::ItemIsEnabled);
table->setItem(i, 0, cell);
}
for (int j=1; j < table->columnCount(); j++){
for (int i=0; i < table->rowCount(); i++ )
{
QTableWidgetItem *cell = new QTableWidgetItem();
cell->setBackground (QBrush(Qt::lightGray));
table->setItem(i, j, cell);
QCheckBox* cb = new QCheckBox(table);
cb->installEventFilter(this);
table->setCellWidget(i, j, cb);
}
}
}
updateColumnTypes();
}
void AssociationsDialog::updateTable(int index)
{
Table *t = findTable(index);
if (!t)
return;
if (active_table != t)
{
active_table = t;
tableCaptionLabel->setText(t->objectName());
table->clearContents();
table->setRowCount(t->numCols());
QStringList colNames = t->colNames();
// this vector will tell which rows should be disabled (cause there's no data in them)
std::vector<bool> disableRow;
disableRow.resize(table->rowCount(), false);
for (int i=0; i<table->rowCount(); i++ )
{
QTableWidgetItem *cell = new QTableWidgetItem(colNames[i]);
cell->setBackground (QBrush(Qt::lightGray));
cell->setFlags (Qt::ItemIsEnabled);
table->setItem(i, 0, cell);
// do we need to disable this row cause the corresponding curve it's empty?
// (empty curves could cause crashes in many other places)
bool allEmpty = true;
// Note possible confusion, here 'table' is the table that you see in the AssociationsDialog,
// whereas t is the underlying data table (spreadsheet).
for (int dataRow = 0; dataRow < t->numRows() && allEmpty; dataRow++)
{
// use i (row in the associations table) as column index
allEmpty = allEmpty & t->text(dataRow, i).isEmpty();
}
if (allEmpty)
disableRow[i] = true;
}
for (int j=1; j < table->columnCount(); j++)
{
for (int i=0; i < table->rowCount(); i++ )
{
QTableWidgetItem *cell = new QTableWidgetItem();
cell->setBackground(QBrush(Qt::lightGray));
cell->setFlags(Qt::ItemIsUserCheckable | Qt::ItemIsEnabled);
table->setItem(i, j, cell);
// disable (but keep the checkbox, as set above)
if (disableRow[i])
cell->setFlags(Qt::NoItemFlags);
}
}
}
updateColumnTypes();
}
void FitDialog::showFitPage()
{
int param_table_rows = boxParams->rowCount();
QString par = boxParam->text().simplified();
QStringList paramList = par.split(QRegExp("[,;]+[\\s]*"), QString::SkipEmptyParts);
int parameters = paramList.count();
boxParams->setRowCount(parameters);
boxParams->hideColumn(2);
if (parameters > 7)
parameters = 7;
boxParams->setMinimumHeight(4+(parameters+1)*boxParams->horizontalHeader()->height());
for (int i = param_table_rows; i<paramList.count(); i++)
{
QTableWidgetItem *it = new QTableWidgetItem(paramList[i]);
it->setFlags(!Qt::ItemIsEditable);
it->setBackground(QBrush(Qt::lightGray));
it->setForeground(QBrush(Qt::darkRed));
QFont font = it->font();
font.setBold(true);
it->setFont(font);
boxParams->setItem(i, 0, it);
it = new QTableWidgetItem(QLocale().toString(1.0, 'f', boxPrecision->value()));
it->setTextAlignment(Qt::AlignRight);
boxParams->setItem(i, 1, it);
}
for (int i = 0; i<paramList.count(); i++)
boxParams->item (i, 0)->setText(paramList[i]);
// FIXME: this check is pretty ugly, should be changed to a more elegant way some time
if (!boxUseBuiltIn->isChecked() ||
(boxUseBuiltIn->isChecked()&& categoryBox->currentRow()!=3 && categoryBox->currentRow()!=1))
{
boxParams->showColumn(2);
for (int i = 0; i<boxParams->rowCount(); i++ )
{
QTableWidgetItem *it = new QTableWidgetItem();
it->setFlags(!Qt::ItemIsEditable);
it->setBackground(QBrush(Qt::lightGray));
boxParams->setItem(i, 2, it);
QCheckBox *cb = new QCheckBox();
boxParams->setCellWidget(i, 2, cb);
}
}
boxFunction->setText(editBox->text().simplified());
lblFunction->setText(boxName->text() +" (x, " + par + ")");
tw->setCurrentWidget (fitPage);
}
int TableWidgetItem::setBackground ( lua_State * L )// ( const QBrush & brush )void
{
QTableWidgetItem* lhs = ValueInstaller2<QTableWidgetItem>::check( L, 1 );
QBrush* brush = ValueInstaller2<QBrush>::check( L, 2 );
lhs->setBackground( *brush );
return 0;
}
void ColorMapEditor::insertLevel()
{
int row = table->currentRow();
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double val = 0.5*(table->item(row, 0)->text().toDouble() + table->item(row - 1, 0)->text().toDouble());
double mapped_val = (val - min_val)/range.width();
QColor c = QColor(color_map.rgb(QwtDoubleInterval(0, 1), mapped_val));
table->blockSignals(true);
table->insertRow(row);
QTableWidgetItem *it = new QTableWidgetItem(QString::number(val));
table->setItem(row, 0, it);
it = new QTableWidgetItem(c.name());
it->setFlags(Qt::ItemFlags(!Qt::ItemIsEditable));
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(row, 1, it);
table->blockSignals(false);
enableButtons(table->currentRow(), 0);
updateColorMap();
}
void ColorMapEditor::setColorMap(const QwtLinearColorMap& map)
{
scaleColorsBox->setChecked(map.mode() == QwtLinearColorMap::ScaledColors);
QwtArray <double> colors = map.colorStops();
int rows = (int)colors.size();
table->setRowCount(rows);
table->blockSignals(true);
for (int i = 0; i < rows; i++)
{
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double val = min_val + colors[i] * range.width();
QTableWidgetItem *it = new QTableWidgetItem(QString::number(val));
table->setItem(i, 0, it);
QColor c = QColor(map.rgb(QwtDoubleInterval(0, 1), colors[i]));
it = new QTableWidgetItem(c.name());
it->setFlags(Qt::ItemFlags(!Qt::ItemIsEditable));
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(i, 1, it);
}
table->blockSignals(false);
color_map = map;
}
void
TagColorEditor::cellDoubleClicked(int row, int col)
{
if (row == 0 && col > 0)
return;
QTableWidgetItem *item = table->item(row, col);
uchar *colors = Global::tagColors();
//int index = row*8 + col;
int index = 0;
if (row > 0) index = 1 + (row-1)*5 + col;
QColor clr = QColor(colors[4*index+0],
colors[4*index+1],
colors[4*index+2]);
clr = DColorDialog::getColor(clr);
if (!clr.isValid())
return;
colors[4*index+0] = clr.red();
colors[4*index+1] = clr.green();
colors[4*index+2] = clr.blue();
item->setData(Qt::DisplayRole, QString("%1").arg(index));
item->setBackground(clr);
emit tagColorChanged();
}
// load AWD_customs_field_list und im Dialog anzeigen
// --------------------------------------------------
void admin::getCustomsfields()
{
QString y;
QSqlQuery query;
qy = "SELECT id,atype,adiftype FROM wawdlist WHERE aset !='0' ORDER BY id";
query.exec(qy);
row = query.size(); // anzahl aedTypen
customsTable->setRowCount(row); // TabellenLänge setzen - col ist schon gesetzt
row = 0;
customsTable->setColumnWidth(0,63);
customsTable->setColumnWidth(1,160);
QBrush brush(QColor(217,207,196));
while(query.next()) {
z = 0;
r = 0;
col = 0;
i = 0;
y = query.value(i++).toString();
QTableWidgetItem *rowItem = new QTableWidgetItem(tr("%1").arg((r++)*(z++))); //idn
rowItem->setText(y);
customsTable->setVerticalHeaderItem(row,rowItem);
QTableWidgetItem *newItem = new QTableWidgetItem(tr("%1").arg((row)*(col)));//dbFeld
newItem->setText(query.value(i++).toString());
customsTable->setItem(row,col++,newItem);
newItem->setBackground(brush);
newItem = new QTableWidgetItem((tr("%1").arg((row)*(col)))); // ADIF_name
newItem->setText(query.value(i).toString());
customsTable->setItem(row,col++,newItem);
row++;
}
}
void QEditAssessment::add()
{
Question q;
questionList.append(q);
// Append to question table
int j = questionTable->rowCount();
questionTable->insertRow(j);
//questionTable->setRowHeight(j, 90);
QTableWidgetItem *item = new QTableWidgetItem(QString::number(j+1));
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
item->setTextAlignment(Qt::AlignHCenter);
questionTable->setItem(j, 0, item);
for (int i=1; i<7 ; i++)
{
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
item->setBackground(QBrush(QColor(255, 255, 255)));
questionTable->setItem(j, i, item);
}
}
void VideoWindow::highlight(int ms)
{
for(int r=0; r < this->eventsPositionInMiliseconds.size(); r++){
QTableWidgetItem* item = this->ui->sequence->item(r,0);
if(this->eventsPositionInMiliseconds.at(r) <= ms+125){
if(this->eventsPositionInMiliseconds.at(r) >= ms-125) item->setBackgroundColor(Qt::green);
else item->setBackgroundColor(QColor(153,255,255));
} else {
QPalette p;
if(r%2==0)
item->setBackground(p.base());
else
item->setBackground(p.alternateBase());
}
}
}
void
TagColorEditor::setColors()
{
QFont fnt("Helvetica", 12);
uchar *colors = Global::tagColors();
for (int i=0; i < 256; i++)
{
int row = i/2;
int col = i%2;
int r,g,b;
float a;
r = colors[4*i+0];
g = colors[4*i+1];
b = colors[4*i+2];
QTableWidgetItem *colorItem = table->item(row, col);
if (!colorItem)
{
colorItem = new QTableWidgetItem;
table->setItem(row, col, colorItem);
}
colorItem->setFont(fnt);
colorItem->setData(Qt::DisplayRole, QString("%1").arg(i));
if (colors[4*i+3] > 250)
colorItem->setCheckState(Qt::Checked);
else
colorItem->setCheckState(Qt::Unchecked);
colorItem->setBackground(QColor(r,g,b));
}
}
QTableWidgetItem* SessionTimesWidget::setItem(int row, int col, QString text, Qt::ItemFlags flags, int align,
QColor textColor, QBrush background)
{
if (ui->timesTableWidget->rowCount() <= row)
{
ui->timesTableWidget->insertRow(row);
// for (int i = 0; i < ui->timesTableWidget->columnCount(); ++i)
// {
// if (i != col)
// ui->timesTableWidget->setItem(row, i, new QTableWidgetItem());
// }
}
QTableWidgetItem *item = ui->timesTableWidget->item(row, col);
if (!item)
{
item = new QTableWidgetItem(text);
item->setFlags(flags);
ui->timesTableWidget->setItem(row, col, item);
}
item->setTextAlignment(align);
item->setBackground(background);
item->setText(text);
item->setTextColor(textColor);
return item;
}
void CQArrayAnnotationsWidget::fillTable1(size_t rowIndex,
const CCopasiAbstractArray::index_type & index)
{
#ifdef DEBUG_UI
qDebug() << "-- in fillTable0 B -- \n";
#endif
if (!mpArray) return;
assert(rowIndex < index.size());
mpContentTable->setColumnCount(1);
mpContentTable->setRowCount((int) mpArray->size()[rowIndex]);
mpContentTable->setHorizontalHeaderItem(0, new QTableWidgetItem(""));
size_t i, imax = mpArray->size()[rowIndex];
CCopasiAbstractArray::index_type Index = index;
//automatic color scaling
if (mAutomaticColorScaling)
{
mpColorScale->startAutomaticParameterCalculation();
for (i = 0; i < imax; ++i)
{
Index[rowIndex] = i;
mpColorScale->passValue((*mpArray->array())[Index]);
}
mpColorScale->finishAutomaticParameterCalculation();
}
//table contents and annotations
const std::vector<std::string> & rowdescr = mpArray->getAnnotationsString(rowIndex);
for (i = 0; i < imax; ++i)
{
Index[rowIndex] = i;
QTableWidgetItem * pItem = new QTableWidgetItem(FROM_UTF8(rowdescr[i]));
mpContentTable->setVerticalHeaderItem((int) i, pItem);
pItem = new QTableWidgetItem(QString::number((*mpArray->array())[Index]));
mpContentTable->setItem((int) i, 0, pItem);
if (mpColorScale != NULL)
{
pItem->setBackground(QBrush(mpColorScale->getColor((*mpArray->array())[Index])));
}
}
mOneDimensional = true;
mpContentTable->resizeRowsToContents();
mpContentTable->resizeColumnsToContents();
if (mpStack->currentIndex() == 1)
fillBarChart();
}
void ValidationResultsView::DisplayResults( const std::vector< fc::Result > &results )
{
m_ResultTable.clear();
if ( results.empty() )
{
DisplayNoProblemsMessage();
return;
}
ConfigureTableForResults();
for ( unsigned int i = 0; i < results.size(); ++i )
{
fc::Result result = results[ i ];
m_ResultTable.insertRow( m_ResultTable.rowCount() );
QBrush row_brush = result.GetResultType() == fc::ResultType_WARNING ?
WARNING_BRUSH :
ERROR_BRUSH;
QTableWidgetItem *item = NULL;
QString path = QString::fromUtf8( result.GetFilepath().c_str() );
item = new QTableWidgetItem( RemoveEpubPathPrefix( path ) );
item->setBackground( row_brush );
m_ResultTable.setItem( i, 0, item );
item = result.GetErrorLine() > 0 ?
new QTableWidgetItem( QString::number( result.GetErrorLine() ) ) :
new QTableWidgetItem( tr( "N/A" ) );
item->setBackground( row_brush );
m_ResultTable.setItem( i, 1, item );
item = new QTableWidgetItem( QString::fromUtf8( result.GetMessage().c_str() ) );
item->setBackground( row_brush );
m_ResultTable.setItem( i, 2, item );
}
// We first force the line number column
// to the smallest needed size...
m_ResultTable.resizeColumnToContents( 0 );
// ... and now the file column can be widened.
m_ResultTable.resizeColumnToContents( 1 );
}
void XMLProtocolParser::fillTable(std::string name, std::string inField)
{
int row = this->gameData->refBox->tbl_info->rowCount();
std::string team = "";
if (cyan)
team = cyanSetup[0];
else if (magenta)
team = magentaSetup[0];
for (int i = 0; i < row; i++)
{
if (this->gameData->refBox->tbl_info->item(i, 0) == nullptr)
{
QTableWidgetItem *item = new QTableWidgetItem();
item->setText(QString::fromStdString(team));
this->gameData->refBox->tbl_info->setItem(i, 0, item);
QTableWidgetItem *item1 = new QTableWidgetItem();
item1->setText(QString::fromStdString(name));
this->gameData->refBox->tbl_info->setItem(i, 1, item1);
QTableWidgetItem *item2 = new QTableWidgetItem();
item2->setText(QString::fromStdString(inField));
this->gameData->refBox->tbl_info->setItem(i, 2, item2);
QTableWidgetItem *item3 = new QTableWidgetItem();
this->gameData->refBox->tbl_info->setItem(i, 3, item3);
if (cyan)
{
item->setBackground(Qt::cyan);
item1->setBackground(Qt::cyan);
item2->setBackground(Qt::cyan);
item3->setBackground(Qt::cyan);
}
else
{
item->setBackground(Qt::magenta);
item1->setBackground(Qt::magenta);
item2->setBackground(Qt::magenta);
item3->setBackground(Qt::magenta);
}
break;
}
}
}
lmcImagePicker::lmcImagePicker(
QWidget *parent,
QList<QString>* source,
int picSize,
int columns,
int* selected,
int actionIndex )
: QTableWidget(parent)
{
setMouseTracking(true);
setBackgroundRole(QPalette::Window);
setIconSize(QSize(picSize, picSize));
setFrameShape(QFrame::NoFrame);
setVerticalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setHorizontalScrollBarPolicy(Qt::ScrollBarAlwaysOff);
setEditTriggers(QAbstractItemView::NoEditTriggers);
setSelectionMode(QAbstractItemView::NoSelection);
setShowGrid(false);
horizontalHeader()->setVisible(false);
verticalHeader()->setVisible(false);
setStyleSheet("QTableWidget { padding: 4px }"); // padding around table
max_col = columns;
int max_row = qCeil(source->count() / (qreal)max_col);
setColumnCount(max_col);
setRowCount(max_row);
int cellSize = picSize + 8;
verticalHeader()->setDefaultSectionSize(cellSize);
verticalHeader()->setMinimumSectionSize(cellSize);
horizontalHeader()->setDefaultSectionSize(cellSize);
horizontalHeader()->setMinimumSectionSize(cellSize);
// set min and max size of table, with padding included
setMinimumSize(max_col * cellSize + 8, max_row * cellSize + 8);
setMaximumSize(max_col * cellSize + 8, max_row * cellSize + 8);
for(int i = 0; i < max_row; i++) {
for(int j = 0; j < max_col; j++) {
int k = (i * max_col) + j;
QTableWidgetItem* item = new QTableWidgetItem();
item->setData(TypeRole, 0);
if(k < source->count()) {
item->setIcon(QIcon(source->value(k)));
item->setData(TypeRole, 1);
item->setSizeHint(QSize(picSize, picSize));
item->setBackground(this->palette().window());
}
setItem(i, j, item);
}
}
this->actionIndex = actionIndex;
this->selected = selected;
this->hoverItem = NULL;
}
void MainWindow::generate() {
for(int i = 0; i < ui->tableWidget->rowCount(); i++) {
for(int j = 0; j < ui->tableWidget->columnCount(); j++) {
QTableWidgetItem* item = new QTableWidgetItem(QString::number(qrand() % 1000));
item->setBackground(Qt::white);
ui->tableWidget->setItem(i, j, item);
}
}
}
void DialogProvinceDetails::SetProvinceItem( ProvinceItem * val )
{
if( val == nullptr )
{
return;
}
ui.lineEditID->setText( QString().setNum(val->GetID()) );
ui.lineEditName->setText( val->GetName() );
ui.listWidget->setSortingEnabled(true);
ui.listWidget->setRowCount( val->GetItemMap().size() );
ui.listWidget->setColumnCount( 2 );
QHeaderView *verticalHeader = ui.listWidget->verticalHeader();
verticalHeader->setSectionResizeMode(QHeaderView::Fixed);
verticalHeader->setDefaultSectionSize(20);
int columnIndex = 0;
ui.listWidget->verticalHeader()->setVisible(false);
ui.listWidget->setSelectionBehavior(QAbstractItemView::SelectRows);
QTableWidgetItem *id = new QTableWidgetItem("Name");
id->setBackground(Qt::lightGray);
ui.listWidget->setHorizontalHeaderItem( columnIndex++, id );
QTableWidgetItem *provinces = new QTableWidgetItem("Wert");
provinces->setBackground(Qt::lightGray);
ui.listWidget->setHorizontalHeaderItem( columnIndex++, provinces );
int rowIndex = 0;
QMap<QString,ItemData>::ConstIterator iter;
for( iter = val->GetItemMap().constBegin(); iter != val->GetItemMap().constEnd(); iter++ )
{
int columnIndex = 0;
ui.listWidget->setItem(rowIndex, columnIndex++, new QTableWidgetItem(iter->GetName()) );
ui.listWidget->item(rowIndex,0)->setTextAlignment(Qt::AlignCenter);
ui.listWidget->setItem(rowIndex, columnIndex++, new QTableWidgetItem( iter->GetData().type() == QVariant::StringList ? iter->GetData().toStringList().join(",") : iter->GetData().toString() ) );
rowIndex++;
}
}
void MessageHandler::showSkippedMessage(int skipped_count)
{
if (skipped_count > 0) {
QTableWidgetItem * item = new QTableWidgetItem(tr("%1 files skipped").arg(skipped_count));
item->setBackground(QBrush(Qt::darkGray));
item->setForeground(QBrush(Qt::white));
item->setIcon(QIcon(":/new/prefix1/images/file.png"));
insertSpannedItem(item);
}
}
void PeersTable::settingsGrid()
{
Asterisk aster;
QHBoxLayout *vbox = new QHBoxLayout;
aster.setHost(Options::getInstance().voip_getIP(QString("Belarus")));
aster.setPort(Options::getInstance().voip_getPort(QString("Belarus")));
aster.setUserName(Options::getInstance().voip_getUserName(QString("Belarus")));
aster.setPassword(Options::getInstance().voip_getPassword(QString("Belarus")));
QList<QStringList> lst = aster.getPeers();
if(lst.size()>0)
{
if (!tablePeers)
tablePeers = new QTableWidget(lst.size(), lst.at(0).size());
else
tablePeers->clear();
tablePeers->setSelectionMode(QAbstractItemView::SingleSelection);
tablePeers->setSelectionBehavior(QAbstractItemView::SelectRows);
tablePeers->verticalHeader()->setDefaultSectionSize(22);
tablePeers->setEditTriggers(QAbstractItemView::NoEditTriggers);
tablePeers->horizontalHeader()->setStretchLastSection(true);
vbox->addWidget(tablePeers);
this->setLayout(vbox);
this->setTitle(tr("Table Peers"));
QStringList tmp;
QColor background;
background.setRgb(79,105,134);
QTableWidgetItem *item;
for(int i=0; i<lst.size();i++)
{
tmp = lst.at(i);
for(int j=0; j< tmp.size();j++)
{
item = new QTableWidgetItem(tmp.at(j));
if(tmp.at(0) == "SIP")
{
item->setBackground(background);
}
tablePeers->setItem(i,j, item);
}
//tablePeers->horizontalHeaderItem(i)->setText(QString());
}
this->setGeometry(x,y,w,h);
}
else
{
vbox->addWidget(new QLabel(tr("Not Peers or bad connection!")));
this->setLayout(vbox);
this->setTitle(QString("Table Peers"));
this->setGeometry(x,y,w,h);
}
}
//================================================================================
//================================================================================
//================================================================================
LoggingTableWidget::LoggingTableWidget( int rows, int columns, QWidget * parent )
: QTableWidget(rows,columns,parent),
RowsAdded(false)
{
TimerScrollToBottom = new QTimer;
TimerScrollToBottom->setInterval(100);
connect(TimerScrollToBottom,SIGNAL(timeout()),SLOT(ScrollToBottom()));
TimerScrollToBottom->start();
setRowCount(0);
setColumnCount(4);
verticalHeader()->setSectionResizeMode(QHeaderView::Fixed);
verticalHeader()->setDefaultSectionSize(20);
// verticalHeader->setVisible(false);
setSelectionBehavior(QAbstractItemView::SelectRows);
horizontalHeader()->setStretchLastSection(true);
QTableWidgetItem *time = new QTableWidgetItem("Time");
time->setBackground(Qt::lightGray);
setHorizontalHeaderItem( 0, time );
QTableWidgetItem *logLevel = new QTableWidgetItem("Log level");
logLevel->setBackground(Qt::lightGray);
setHorizontalHeaderItem( 1, logLevel );
QTableWidgetItem *category = new QTableWidgetItem("Category");
category->setBackground(Qt::lightGray);
setHorizontalHeaderItem( 2, category );
QTableWidgetItem *message = new QTableWidgetItem("Message");
message->setBackground(Qt::lightGray);
setHorizontalHeaderItem( 3, message );
horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
}
void TracksConfigDialog::slotDelete()
{
int row = table->currentRow();
int trackToDelete = table->rowCount() - row;
if (row < 0 || m_deletedRows.contains(trackToDelete))
return;
m_deletedRows.append(trackToDelete);
qSort(m_deletedRows);
for (int i = 0; i < table->columnCount(); ++i) {
QTableWidgetItem *item = table->item(row, i);
item->setFlags(Qt::NoItemFlags);
item->setBackground(palette().dark());
}
}
void MainWindow::on_calc3_clicked()
{
int count = 0;
for(int i = 0; i < ui->tableWidget->rowCount(); i++) {
for(int j = 0; j < ui->tableWidget->columnCount(); j++) {
QTableWidgetItem* item = ui->tableWidget->item(i, j);
int val = item->text().toInt();
if(checkIfPowerOf3(val)) {
item->setBackground(Qt::blue);
count++;
}
}
}
ui->textField->setText("Степеней тройки: " + QString::number(count));
QMessageBox::information(this, "Степени тройки", "Найдено: " + QString::number(count));
}
void MainWindow::on_findMax_clicked()
{
double max = 0;
for(int i = 0; i < ui->tableWidget->rowCount(); i++) {
for(int j = 0; j < ui->tableWidget->columnCount(); j++) {
QTableWidgetItem* item = ui->tableWidget->item(i, j);
item->setBackground(Qt::white);
double val = item->text().toDouble();
if(val > max) {
max = val;
}
}
}
ui->textField->setText("Максимальное число: " + QString::number(max));
QMessageBox::information(this, "Максимальное число", "Максимальное число: " + QString::number(max));
}
void ColorMapEditor::insertLevel()
{
int row = table->currentRow();
DoubleSpinBox *sb = (DoubleSpinBox*)table->cellWidget(row, 0);
if (!sb)
return;
double current_value = sb->value();
double previous_value = min_val;
sb = (DoubleSpinBox*)table->cellWidget(row - 1, 0);
if (sb)
previous_value = sb->value();
double val = 0.5*(current_value + previous_value);
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
double mapped_val = (val - min_val)/range.width();
QColor c = QColor(color_map.rgb(QwtDoubleInterval(0, 1), mapped_val));
table->blockSignals(true);
table->insertRow(row);
sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(val);
sb->setRange(min_val, max_val);
connect(sb, SIGNAL(valueChanged(double)), this, SLOT(updateColorMap()));
connect(sb, SIGNAL(activated(DoubleSpinBox *)), this, SLOT(spinBoxActivated(DoubleSpinBox *)));
table->setCellWidget(row, 0, sb);
QTableWidgetItem *it = new QTableWidgetItem(c.name());
// Avoid compiler warning
//#ifdef Q_CC_MSVC
it->setFlags(it->flags() & (~Qt::ItemIsEditable));
//#else
// it->setFlags(!Qt::ItemIsEditable);
//#endif
it->setBackground(QBrush(c));
it->setForeground(QBrush(c));
table->setItem(row, 1, it);
table->blockSignals(false);
enableButtons(table->currentRow());
updateColorMap();
}
QTableWidgetItem* SessionAnalysisWidget::setItem(QTableWidget *table, int row, int col, QString text, Qt::ItemFlags flags, int align,
QColor textColor, QBrush background)
{
QTableWidgetItem *item = table->item(row, col);
if (!item)
{
item = new QTableWidgetItem(text);
item->setFlags(flags);
table->setItem(row, col, item);
}
item->setTextAlignment(align);
item->setBackground(background);
item->setText(text);
item->setTextColor(textColor);
return item;
}
/** should be called in constructor for basic setup of
* table cells.
*/
void RatingsTable::setupCells()
{
PlayerList players = _group->const_validPlayers();
int plCnt = players.count();
setRowCount( plCnt + 1 );
setColumnCount( plCnt + 1 + 1 ); // 1 column for total rating results
for ( int i = 0; i < rowCount(); i ++ ) {
for ( int j = 0; j < plCnt + 1; j ++ ) {
QTableWidgetItem *item = new QTableWidgetItem( );
QString text;
if ( i == j ) {
item->setBackground( palette().brush( QPalette::Disabled,
QPalette::Background ) );
if ( i == 0 ) {
text = _group->name();
}
item->setFlags( Qt::NoItemFlags );
} else if ( i == 0 ) { // 0th row
text = players.at( j - 1 ).name();
item->setFlags( Qt::NoItemFlags );
} else if ( j == 0 ) { // 0th column
Player p = players.at( i - 1 );
text = p.name();
text += " (" + QString::number( p.rating(), 'f', 1 ) + ")";
item->setFlags( Qt::NoItemFlags );
} else {
item->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
}
item->setText( text );
setItem( i, j, item );
}
QTableWidgetItem *item = new QTableWidgetItem( );
if ( i == 0 ) {
item->setText( tr( "New rating" ) );
}
item->setFlags( Qt::NoItemFlags );
setItem( i, plCnt + 1, item );
}
}
void PMeshViewer::setColor(int row, int col)
{
if (col != 1)
return;
QColor color = QColorDialog::getColor();
if (!color.isValid())
return;
QTableWidgetItem *item = meshTable->item(row, col);
item->setBackground(QBrush(color));
double red = color.red() / 255.0;
double green = color.green() / 255.0;
double blue = color.blue() / 255.0;
meshList[row].actor->GetProperty()->SetColor(red, green, blue);
renderWindow->Render();
}
void QEditAssessment::add(Question q)
{
questionList.append(q);
// Append to question table
int j = questionTable->rowCount();
questionTable->insertRow(j);
//questionTable->setRowHeight(j, 90);
QTableWidgetItem *item = new QTableWidgetItem(QString::number(j+1));
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
item->setTextAlignment(Qt::AlignHCenter);
questionTable->setItem(j, 0, item);
for (int i=1; i<7 ; i++)
{
item = new QTableWidgetItem;
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsEditable);
item->setTextAlignment(Qt::AlignHCenter);
item->setBackground(QBrush(QColor(255, 255, 255)));
switch(i)
{
case 1:
item->setText(q.content);
break;
case 2:
item->setText(q.choiceA);
break;
case 3:
item->setText(q.choiceB);
break;
case 4:
item->setText(q.choiceC);
break;
case 5:
item->setText(q.choiceD);
break;
case 6:
item->setText(q.answer);
break;
}
questionTable->setItem(j, i, item);
}
}
