void VotePage::fillParkRateTable()
{
QTableWidget* table = ui->parkRateTable;
std::vector<CParkRate> parkRates;
BOOST_FOREACH(const CParkRateVote& parkRateResult, lastBestBlock->vParkRateResult)
{
if (parkRateResult.cUnit == 'B')
{
parkRates = parkRateResult.vParkRate;
break;
}
}
table->setRowCount(parkRates.size());
for (size_t i = 0; i < parkRates.size(); i++)
{
const CParkRate& parkRate = parkRates[i];
QString durationString = GUIUtil::blocksToTime(parkRate.GetDuration());
QTableWidgetItem *durationItem = new QTableWidgetItem(durationString);
durationItem->setData(Qt::TextAlignmentRole, QVariant(Qt::AlignRight | Qt::AlignVCenter));
table->setItem(i, 0, durationItem);
double interestRate = GUIUtil::annualInterestRatePercentage(parkRate.nRate, parkRate.GetDuration());
QString rateString = QString("%L1%").arg(interestRate, 0, 'f', 3);
QTableWidgetItem *rateItem = new QTableWidgetItem(rateString);
rateItem->setData(Qt::TextAlignmentRole, QVariant(Qt::AlignRight | Qt::AlignVCenter));
table->setItem(i, 1, rateItem);
}
table->setVisible(false);
table->resizeColumnsToContents();
table->setVisible(true);
}
void SkillEditFrame::onCurrentItemChanged(DataContainerItem *current) {
if (current == 0)
return;
QTableWidget *skillTable = this->findChild<QTableWidget *>("skillTable");
DataContainerItem *item = current;
if (item->getStringData().size() > 0) {
StatsContainer *skill = GenStatsReader::getContainer(*skillStats, item->getStringData());
if (skill != 0) {
typedef std::map<std::string, std::string> StringMap;
StringMap dataMap = skill->getBaseDataMap();
for (int i=0; i<skillTable->rowCount(); ++i) {
for (int j=0; j<skillTable->columnCount(); ++j) {
delete skillTable->item(i, j);
}
}
skillTable->setRowCount(0);
int row = 0;
for (StringMap::iterator it = dataMap.begin(); it != dataMap.end(); ++it) {
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setText(it->first.c_str());
QTableWidgetItem *valueItem = new QTableWidgetItem();
valueItem->setText(it->second.c_str());
skillTable->insertRow(row);
skillTable->setItem(row, 0, nameItem);
skillTable->setItem(row, 1, valueItem);
++row;
}
skillTable->resizeRowsToContents();
skillTable->resizeColumnsToContents();
}
}
}
InformationPanel::InformationPanel(QWidget *parent)
: ConfiguratorPanel(false, parent) {
_name = "Information";
_icon = QIcon(":/res/icons/info.png");
setHeadline("Information");
setDescription("System paths and variables");
QVBoxLayout *l = new QVBoxLayout;
l->setMargin(0);
setLayout(l);
QTableWidget *table = new QTableWidget;
table->setFrameShape(QFrame::NoFrame);
table->setColumnCount(2);
table->verticalHeader()->setVisible(false);
table->horizontalHeader()->setStretchLastSection(true);
table->horizontalHeader()->setDefaultAlignment(Qt::AlignLeft);
table->setHorizontalHeaderLabels(QStringList() << "Name" << "Value");
table->setAlternatingRowColors(true);
table->setSelectionMode(QAbstractItemView::NoSelection);
l->addWidget(table);
Seiscomp::Environment *env = Seiscomp::Environment::Instance();
addRow(table, "PATH", getenv("PATH"));
addRow(table, "ROOTDIR", env->installDir().c_str());
addRow(table, "DEFAULTCONFIGDIR", env->globalConfigDir().c_str());
addRow(table, "SYSTEMCONFIGDIR", env->appConfigDir().c_str());
addRow(table, "CONFIGDIR", env->configDir().c_str());
addRow(table, "LOGDIR", env->logDir().c_str());
addRow(table, "DATADIR", env->shareDir().c_str());
table->resizeColumnsToContents();
}
void VotePage::fillCustodianTable()
{
QTableWidget* table = ui->custodianTable;
table->setRowCount(0);
int row = 0;
for (CBlockIndex* pindex = lastBestBlock; pindex; pindex = pindex->pprevElected)
{
BOOST_FOREACH(const CCustodianVote& custodianVote, pindex->vElectedCustodian)
{
table->setRowCount(row + 1);
QTableWidgetItem *addressItem = new QTableWidgetItem();
addressItem->setData(Qt::DisplayRole, QString::fromStdString(custodianVote.GetAddress().ToString()));
table->setItem(row, 0, addressItem);
QTableWidgetItem *amountItem = new QTableWidgetItem();
amountItem->setData(Qt::DisplayRole, BitcoinUnits::format(model->getOptionsModel()->getDisplayUnit(), custodianVote.nAmount));
amountItem->setData(Qt::TextAlignmentRole, QVariant(Qt::AlignRight | Qt::AlignVCenter));
table->setItem(row, 1, amountItem);
QTableWidgetItem *dateItem = new QTableWidgetItem();
dateItem->setData(Qt::DisplayRole, GUIUtil::dateTimeStr(pindex->nTime));
table->setItem(row, 2, dateItem);
row++;
}
}
table->setVisible(false);
table->resizeColumnsToContents();
table->setVisible(true);
}
/**
* @brief apply query records <resolver>;<domain>;<nic>;<latency>;<error>;<type>;<start>;<end>;
*/
void OpenNICQueryHistoryDialog::history(QStringList& queries)
{
QTableWidget* table = ui->queryHistory;
table->setRowCount(queries.count());
for(int row=0; row < queries.count(); row++)
{
QStringList columns = queries[row].split(";");
for(int col=0; col < columns.count(); col++)
{
table->setItem(row,col,new QTableWidgetItem(columns[col]));
}
}
table->resizeColumnsToContents();
table->resizeRowsToContents();
}
/**
* @brief Updates the resolver pool display.
*/
void OpenNIC::updateResolverPool(QStringList resolverPool)
{
/* @brief <status>;<score>;<kind>;<hostAddress>; */
QTableWidget* table = ui->resolverPoolTable;
double minScore,maxScore;
scoreMinMax(resolverPool, minScore, maxScore);
table->setRowCount(resolverPool.count());
for(int row=0; row < resolverPool.count(); row++ )
{
QStringList elements = resolverPool.at(row).split(";");
QString ip = elements.at(3);
QString kind = elements.at(2);
QString score = elements.at(1);
QString status = elements.at(0);
QString statusIcon;
if (status == "R")
{
status = tr("FAIL");
statusIcon = ":/images/status-red.png";
}
else if (status == "G")
{
status = tr("OK");
statusIcon = ":/images/status-green.png";
}
else if (status == "Y")
{
status = tr("WARN");
statusIcon = ":/images/status-yellow.png";
}
table->setItem(row,3,new QTableWidgetItem(ip));
table->setItem(row,2,new QTableWidgetItem(kind));
#if 0
table->setItem(row,1,new QTableWidgetItem(score));
#else
QProgressBar* bar = new QProgressBar();
bar->setRange((int)(minScore*1000.0),(int)(maxScore*1000.0));
bar->setValue((int)(score.toDouble()*1000.0));
table->setCellWidget(row,1,bar);
#endif
table->setItem(row,0,new QTableWidgetItem(QIcon(statusIcon),status));
}
table->resizeColumnsToContents();
table->resizeRowsToContents();
table->setSortingEnabled(true);
table->sortByColumn(1,Qt::DescendingOrder);
}
void ListingTracePane::setListingTrace(QStringList listingTraceList, QList<bool> hasCheckBox)
{
// tableWidget depends on whether we are assembling the OS or a program
QTableWidget *tableWidget;
if (Pep::memAddrssToAssemblerListing == &Pep::memAddrssToAssemblerListingProg) {
tableWidget = ui->listingTraceTableWidget;
}
else {
tableWidget = ui->listingPepOsTraceTableWidget;
}
QTableWidgetItem *item;
int numRows = listingTraceList.size();
tableWidget->setRowCount(numRows);
for (int i = 0; i < numRows; i++) {
item = new QTableWidgetItem(listingTraceList[i]);
tableWidget->setItem(i, 1, item);
}
for (int i = 0; i < numRows; i++) {
item = new QTableWidgetItem();
if (hasCheckBox[i]) {
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsUserCheckable);
item->setCheckState(Qt::Unchecked);
}
else {
item->setFlags(Qt::NoItemFlags);
}
tableWidget->setItem(i, 0, item);
}
tableWidget->resizeColumnsToContents();
ui->listingTraceTableWidget->width();
tableWidget->resizeRowsToContents();
// if (Pep::memAddrssToAssemblerListing == &Pep::memAddrssToAssemblerListingProg) {
// programDocWidth = tableWidget->columnWidth(1);
// }
// else {
// osDocWidth = tableWidget->columnWidth(1);
// }
// resizeDocWidth();
tableWidget->horizontalScrollBar()->setValue(tableWidget->horizontalScrollBar()->minimum());
}
KeyBinder::KeyBinder(QWidget * parent, const QString & helpText, const QString & defaultText, const QString & resetButtonText) : QWidget(parent)
{
this->defaultText = defaultText;
enableSignal = false;
// Two-column tab layout
QHBoxLayout * pageKeysLayout = new QHBoxLayout(this);
pageKeysLayout->setSpacing(0);
pageKeysLayout->setContentsMargins(0, 0, 0, 0);
// Table for category list
QVBoxLayout * catListContainer = new QVBoxLayout();
catListContainer->setContentsMargins(10, 10, 10, 10);
catList = new QListWidget();
catList->setFixedWidth(180);
catList->setStyleSheet("QListWidget::item { font-size: 14px; } QListWidget:hover { border-color: #F6CB1C; } QListWidget::item:selected { background: #150A61; color: yellow; }");
catList->setFocusPolicy(Qt::NoFocus);
connect(catList, SIGNAL(currentRowChanged(int)), this, SLOT(changeBindingsPage(int)));
catListContainer->addWidget(catList);
pageKeysLayout->addLayout(catListContainer);
// Reset all binds button
if (!resetButtonText.isEmpty())
{
QPushButton * btnResetAll = new QPushButton(resetButtonText);
catListContainer->addWidget(btnResetAll);
btnResetAll->setFixedHeight(40);
catListContainer->setStretch(1, 0);
catListContainer->setSpacing(10);
connect(btnResetAll, SIGNAL(clicked()), this, SIGNAL(resetAllBinds()));
}
// Container for pages of key bindings
QWidget * bindingsPagesContainer = new QWidget();
QVBoxLayout * rightLayout = new QVBoxLayout(bindingsPagesContainer);
// Scroll area for key bindings
QScrollArea * scrollArea = new QScrollArea();
scrollArea->setContentsMargins(0, 0, 0, 0);
scrollArea->setWidget(bindingsPagesContainer);
scrollArea->setVerticalScrollBarPolicy(Qt::ScrollBarAsNeeded);
scrollArea->setWidgetResizable(true);
scrollArea->setFrameShape(QFrame::NoFrame);
scrollArea->setStyleSheet("background: #130F2A;");
// Add key binding pages to bindings tab
pageKeysLayout->addWidget(scrollArea);
pageKeysLayout->setStretch(1, 1);
// Custom help text
QLabel * helpLabel = new QLabel();
helpLabel->setText(helpText);
helpLabel->setStyleSheet("color: #130F2A; background: #F6CB1C; border: solid 4px #F6CB1C; border-radius: 10px; padding: auto 20px;");
helpLabel->setFixedHeight(24);
rightLayout->addWidget(helpLabel, 0, Qt::AlignCenter);
// Category list and bind table row heights
const int rowHeight = 20;
QSize catSize, headerSize;
catSize.setHeight(36);
headerSize.setHeight(24);
// Category list header
QListWidgetItem * catListHeader = new QListWidgetItem(tr("Category"));
catListHeader->setSizeHint(headerSize);
catListHeader->setFlags(Qt::NoItemFlags);
catListHeader->setForeground(QBrush(QColor("#130F2A")));
catListHeader->setBackground(QBrush(QColor("#F6CB1C")));
catListHeader->setTextAlignment(Qt::AlignCenter);
catList->addItem(catListHeader);
// Populate
bindingsPages = new QHBoxLayout();
bindingsPages->setContentsMargins(0, 0, 0, 0);
rightLayout->addLayout(bindingsPages);
QWidget * curPage = NULL;
QVBoxLayout * curLayout = NULL;
QTableWidget * curTable = NULL;
bool bFirstPage = true;
selectedBindTable = NULL;
bindComboBoxCellMappings = new QHash<QObject *, QTableWidgetItem *>();
bindCellComboBoxMappings = new QHash<QTableWidgetItem *, QComboBox *>();
for (int i = 0; i < BINDS_NUMBER; i++)
{
if (cbinds[i].category != NULL)
{
// Add stretch at end of previous layout
if (curLayout != NULL) curLayout->insertStretch(-1, 1);
// Category list item
QListWidgetItem * catItem = new QListWidgetItem(HWApplication::translate("binds (categories)", cbinds[i].category));
catItem->setSizeHint(catSize);
catList->addItem(catItem);
// Create new page
curPage = new QWidget();
curLayout = new QVBoxLayout(curPage);
curLayout->setSpacing(2);
bindingsPages->addWidget(curPage);
if (!bFirstPage) curPage->setVisible(false);
}
// Description
if (cbinds[i].description != NULL)
{
QLabel * desc = new QLabel(HWApplication::translate("binds (descriptions)", cbinds[i].description));
curLayout->addWidget(desc, 0);
QFrame * divider = new QFrame();
divider->setFrameShape(QFrame::HLine);
divider->setFrameShadow(QFrame::Plain);
curLayout->addWidget(divider, 0);
}
// New table
if (cbinds[i].category != NULL || cbinds[i].description != NULL)
{
curTable = new QTableWidget(0, 2);
curTable->verticalHeader()->setVisible(false);
curTable->horizontalHeader()->setVisible(false);
curTable->horizontalHeader()->setResizeMode(QHeaderView::Stretch);
curTable->verticalHeader()->setDefaultSectionSize(rowHeight);
curTable->setShowGrid(false);
curTable->setStyleSheet("QTableWidget { border: none; } ");
curTable->setSelectionBehavior(QAbstractItemView::SelectRows);
curTable->setSelectionMode(QAbstractItemView::SingleSelection);
curTable->setFocusPolicy(Qt::NoFocus);
connect(curTable, SIGNAL(itemSelectionChanged()), this, SLOT(bindSelectionChanged()));
connect(curTable, SIGNAL(itemClicked(QTableWidgetItem *)), this, SLOT(bindCellClicked(QTableWidgetItem *)));
curLayout->addWidget(curTable, 0);
}
// Hidden combo box
QComboBox * comboBox = CBBind[i] = new QComboBox(curTable);
comboBox->setModel((QAbstractItemModel*)DataManager::instance().bindsModel());
comboBox->setVisible(false);
comboBox->setFixedWidth(200);
// Table row
int row = curTable->rowCount();
QTableWidgetItem * nameCell = new QTableWidgetItem(HWApplication::translate("binds", cbinds[i].name));
nameCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->insertRow(row);
curTable->setItem(row, 0, nameCell);
QTableWidgetItem * bindCell = new QTableWidgetItem(comboBox->currentText());
bindCell->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
curTable->setItem(row, 1, bindCell);
curTable->resizeColumnsToContents();
curTable->setFixedHeight(curTable->verticalHeader()->length() + 10);
// Updates the text in the table cell
connect(comboBox, SIGNAL(currentIndexChanged(const QString &)), this, SLOT(bindChanged(const QString &)));
// Map combo box and that row's cells to each other
bindComboBoxCellMappings->insert(comboBox, bindCell);
bindCellComboBoxMappings->insert(nameCell, comboBox);
bindCellComboBoxMappings->insert(bindCell, comboBox);
}
void InfoDialog::setupUi(const Tags &tags)
{
int row = 0;
QVBoxLayout *layout = new QVBoxLayout;
layout->setContentsMargins(0,0,0,0);
setWindowTitle(tr("EXIF information"));
if (!tags.fileName().isEmpty())
setWindowTitle(windowTitle() + " - " + QFileInfo(tags.fileName()).fileName());
setWindowIcon(QIcon(":images/exif_info"));
if (tags.size())
{
QMapIterator<int, QPair<Tag, Data> > tag(tags);
QTableWidget *tableWidget = new QTableWidget(tags.size(),2,this);
tableWidget->setAlternatingRowColors(true);
tableWidget->verticalHeader()->setVisible(false);
tableWidget->setEditTriggers(QAbstractItemView::NoEditTriggers);
tableWidget->setSelectionMode(QAbstractItemView::NoSelection);
tableWidget->setHorizontalHeaderItem(0,new QTableWidgetItem(tr("Tag")));
tableWidget->setHorizontalHeaderItem(1,new QTableWidgetItem(tr("Value")));
tableWidget->horizontalHeader()->setStretchLastSection(true);
while (tag.hasNext())
{
QTableWidgetItem *item;
QPair<Tag,Data> exifValue = tag.next().value();
item = new QTableWidgetItem(exifValue.first.title);
item->setToolTip(exifValue.first.description.split(". ",QString::SkipEmptyParts).join("\n"));
tableWidget->setItem(row,0,item);
item = new QTableWidgetItem(exifValue.second.readableValue);
item->setToolTip(exifValue.first.description.split(". ",QString::SkipEmptyParts).join("\n"));
tableWidget->setItem(row++,1,item);
}
tableWidget->resizeColumnsToContents();
tableWidget->resizeRowsToContents();
layout->addWidget(tableWidget);
}
else
{
QLabel *label = new QLabel(tr("No EXIF information available"),this);
label->setAlignment(Qt::AlignCenter);
layout->addWidget(label);
}
#ifdef Q_WS_MAC
QDialogButtonBox *buttonBox = new QDialogButtonBox(QDialogButtonBox::Ok,Qt::Horizontal,this);
connect(buttonBox,SIGNAL(accepted()),this,SLOT(close()));
layout->addWidget(buttonBox);
#endif
setLayout(layout);
resize(600,400);
}
void CQMathMatrixWidget::slotDerivButtonPressed()
{
#ifdef _DERIV_TEST_
std::cout << "Deriv" << std::endl;
CModel* pModel = CCopasiRootContainer::getDatamodelList()->operator[](0).getModel();
CEvaluationNode* tmpnode = pModel->prepareElasticity(&pModel->getReactions()[0],
&pModel->getMetabolites()[0], false);
CEvaluationNode* tmpnode2 = pModel->prepareElasticity(&pModel->getReactions()[0],
&pModel->getMetabolites()[0], true);
//create empty environment. Variable nodes should not occur in an expression
std::vector<std::vector<std::string> > env;
std::string tmpstring = tmpnode->buildMMLString(false, env);
std::string tmpstring2 = tmpnode2->buildMMLString(false, env);
mpMML->setBaseFontPointSize(qApp->font().pointSize());
mpMML->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
mpMML->setContent(tmpstring.c_str());
mpMML2->setBaseFontPointSize(qApp->font().pointSize());
mpMML2->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
mpMML2->setContent(tmpstring2.c_str());
QTableWidget * pTable = new QTableWidget(pModel->getReactions().size(), pModel->getMetabolites().size());
pTable->show();
int i, imax = pModel->getMetabolites().size();
int j, jmax = pModel->getReactions().size();
for (i = 0; i < imax; ++i)
for (j = 0; j < jmax; ++j)
{
//CEvaluationNode* tmpnode = pModel->prepareElasticity(pModel->getReactions()[j],
// pModel->getMetabolites()[i], false);
CEvaluationNode* tmpnode2 = pModel->prepareElasticity(&pModel->getReactions()[j],
&pModel->getMetabolites()[i], true);
//evaluate
CExpression * tmpExp = new CExpression("tmp expr", pModel);
tmpExp->setRoot(tmpnode2);
tmpExp->compile();
std::cout << tmpExp->calcValue() << std::endl;
//create empty environment. Variable nodes should not occur in an expression
std::vector<std::vector<std::string> > env;
//std::string tmpstring = tmpnode->buildMMLString(false, env);
std::string tmpstring2 = tmpnode2->buildMMLString(false, env);
QtMmlWidget* tmpmml = new QtMmlWidget();
tmpmml->setBaseFontPointSize(qApp->font().pointSize() - 2);
tmpmml->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
tmpmml->setContent(tmpstring2.c_str());
pTable->setCellWidget(j, i, tmpmml);
//tmpmml = new QtMmlWidget();
//tmpmml->setBaseFontPointSize(qApp->font().pointSize()-2);
//tmpmml->setFontName(QtMmlWidget::NormalFont, qApp->font().family());
//tmpmml->setContent(tmpstring.c_str());
//pTable->setCellWidget(i, 1, tmpmml);
}
pTable->resizeColumnsToContents();
pTable->resizeRowsToContents();
#endif
}
void StatsView::on_statsTree_currentItemChanged(QTreeWidgetItem *current, QTreeWidgetItem *previous)
{
if (current == 0)
return;
std::string data = "";
if (current->childCount() == 0) {
DataContainerTreeItem *treeData = (DataContainerTreeItem *)current;
data = treeData->getData();
}
QTreeWidget *statsTree = this->findChild<QTreeWidget *>("statsTree");
QLabel *modName = this->findChild<QLabel *>("modName");
QTableWidget *modTable = this->findChild<QTableWidget *>("modTable");
modTable->blockSignals(true);
StatsContainer *itemStats = GenStatsReader::getContainer(allItemStats, data.c_str());
if (itemStats != 0) {
modName->setText(itemStats->getArg(0).c_str());
std::map<std::string, std::string> baseData = itemStats->getBaseDataMap();
if (itemStats->getUsing() != 0) {
std::map<std::string, std::string> parentData = itemStats->getUsing()->getBaseDataMap();
for (std::map<std::string, std::string>::iterator it = parentData.begin(); it != parentData.end(); ++it) {
if (baseData.find(it->first) == baseData.end()) {
baseData[it->first] = it->second;
}
}
}
for (int i=0; i<modTable->rowCount(); ++i) {
for (int j=0; j<modTable->columnCount(); ++j) {
delete modTable->item(i, j);
}
}
modTable->setRowCount(0);
int row = 0;
if (itemStats->getContainerType() == "deltamod") {
StatsContainer *boost = GenStatsReader::getContainer(allItemStats, itemStats->getBoostName());
if (boost != 0) {
std::map<std::string, std::string> boostMap = boost->getBaseDataMap();
for (std::map<std::string, std::string>::iterator it = boostMap.begin(); it != boostMap.end(); ++it) {
if (baseData.find(it->first) == baseData.end()) {
baseData[it->first] = it->second;
}
}
}
for (int i=0; i<itemStats->getPrefixList().size(); ++i) {
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
nameItem->setText("Prefix");
QTableWidgetItem *valueItem = new QTableWidgetItem();
valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
valueItem->setText(itemStats->getPrefixList()[i].c_str());
modTable->insertRow(row);
modTable->setItem(row, 0, nameItem);
modTable->setItem(row, 1, valueItem);
++row;
}
for (int i=0; i<itemStats->getSuffixList().size(); ++i) {
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
nameItem->setText("Suffix");
QTableWidgetItem *valueItem = new QTableWidgetItem();
valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
valueItem->setText(itemStats->getSuffixList()[i].c_str());
modTable->insertRow(row);
modTable->setItem(row, 0, nameItem);
modTable->setItem(row, 1, valueItem);
++row;
}
}
for (std::map<std::string, std::string>::iterator it = baseData.begin(); it != baseData.end(); ++it) {
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
nameItem->setText(it->first.c_str());
QTableWidgetItem *valueItem = new QTableWidgetItem();
valueItem->setFlags(valueItem->flags() & ~Qt::ItemIsEditable);
valueItem->setText(it->second.c_str());
modTable->insertRow(row);
modTable->setItem(row, 0, nameItem);
modTable->setItem(row, 1, valueItem);
++row;
}
modTable->resizeRowsToContents();
modTable->resizeColumnsToContents();
} else if (current->childCount() == 0) {
bool canEdit = true;
if (current->text(0) == "Abilities") {
canEdit = false;
}
QStringList headerList;
headerList.push_back("Name");
if (canEdit) {
headerList.push_back("Editable Value");
} else {
headerList.push_back("Value");
}
modTable->setHorizontalHeaderLabels(headerList);
for (int i=0; i<modTable->rowCount(); ++i) {
for (int j=0; j<modTable->columnCount(); ++j) {
delete modTable->item(i, j);
}
}
modTable->setRowCount(0);
int row = 0;
modTable->insertRow(row);
QTableWidgetItem *nameItem = new QTableWidgetItem();
nameItem->setText(current->text(0));
nameItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
modTable->setItem(row, 0, nameItem);
QTableWidgetItem *valueItem = new QTableWidgetItem();
if (!canEdit) {
valueItem->setFlags(nameItem->flags() & ~Qt::ItemIsEditable);
}
valueItem->setText(data.c_str());
modTable->setItem(row, 1, valueItem);
modTable->resizeRowsToContents();
modTable->resizeColumnsToContents();
}
modTable->blockSignals(false);
}