void SortedSetKeyModel::setCurrentPage(int page)
{
if (page == currentPage) {
return;
}
clear();
QStringList labels;
labels << "Value" << "Score";
setHorizontalHeaderLabels(labels);
currentPage = page;
int size = rawData.size();
setRowCount( (itemsOnPageLimit > size / 2)? size / 2 : itemsOnPageLimit);
int startShiftPosition = itemsOnPageLimit * 2 * (currentPage - 1);
int limit = startShiftPosition + itemsOnPageLimit * 2;
for (int i = startShiftPosition, row = 0; i < limit && i < size; ++i, ++row) {
QStandardItem * key = new QStandardItem(rawData.at(i));
QStandardItem * value = new QStandardItem(rawData.at(++i));
setItem(row, 0, key);
setItem(row, 1, value);
}
}
DataTableWidget::DataTableWidget(IDataForms *ADataForms, const IDataTable &ATable, QWidget *AParent) : QTableWidget(AParent)
{
FTable = ATable;
FDataForms = ADataForms;
setRowCount(ATable.rows.count());
setColumnCount(ATable.columns.count());
int row = 0;
foreach(const QStringList &values, ATable.rows)
{
for (int col=0; col<values.count(); col++)
{
QTableWidgetItem *item = new QTableWidgetItem(values.at(col));
item->setData(DTR_COL_INDEX,col);
item->setData(DTR_ROW_INDEX,row);
item->setFlags(Qt::ItemIsEnabled);
setItem(row,col,item);
}
row++;
}
QStringList headers;
foreach(const IDataField &field, ATable.columns)
headers.append(!field.label.isEmpty() ? field.label : field.var);
setHorizontalHeaderLabels(headers);
horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
verticalHeader()->resizeSections(QHeaderView::ResizeToContents);
setSizePolicy(QSizePolicy::Expanding,QSizePolicy::Expanding);
connect(this,SIGNAL(cellActivated(int,int)),SIGNAL(activated(int,int)));
connect(this,SIGNAL(currentCellChanged(int,int,int,int)),SIGNAL(changed(int,int,int,int)));
}
AdvancedSettings::AdvancedSettings(QWidget *parent)
: QTableWidget(parent)
{
// column
setColumnCount(COL_COUNT);
QStringList header = {tr("Setting"), tr("Value", "Value set for this setting")};
setHorizontalHeaderLabels(header);
// row
setRowCount(ROW_COUNT);
verticalHeader()->setVisible(false);
// etc.
setAlternatingRowColors(true);
setSelectionMode(QAbstractItemView::NoSelection);
setEditTriggers(QAbstractItemView::NoEditTriggers);
// Signals
connect(&spinBoxCache, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged)
, this, &AdvancedSettings::updateCacheSpinSuffix);
connect(&comboBoxInterface, static_cast<void (QComboBox::*)(int)>(&QComboBox::currentIndexChanged)
, this, &AdvancedSettings::updateInterfaceAddressCombo);
connect(&spinBoxSaveResumeDataInterval, static_cast<void (QSpinBox::*)(int)>(&QSpinBox::valueChanged)
, this, &AdvancedSettings::updateSaveResumeDataIntervalSuffix);
// Load settings
loadAdvancedSettings();
resizeColumnToContents(0);
horizontalHeader()->setStretchLastSection(true);
}
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;
}
bool MatrixModel::calculate(int startRow, int endRow, int startCol, int endCol)
{
QString formula = d_matrix->formula();
if (formula.isEmpty())
return false;
QApplication::setOverrideCursor(QCursor(Qt::WaitCursor));
ScriptingEnv *scriptEnv = d_matrix->scriptingEnv();
Script *script = scriptEnv->newScript(formula, this, QString("<%1>").arg(objectName()));
connect(script, SIGNAL(error(const QString&,const QString&,int)), scriptEnv, SIGNAL(error(const QString&,const QString&,int)));
connect(script, SIGNAL(print(const QString&)), scriptEnv, SIGNAL(print(const QString&)));
if (!script->compile()){
QApplication::restoreOverrideCursor();
return false;
}
if (endRow < 0)
endRow = d_rows - 1;
if (endCol < 0)
endCol = d_cols - 1;
if (endCol >= d_cols)
setColumnCount(endCol + 1);
if (endRow >= d_rows)
setRowCount(endRow + 1);
QVariant res;
double dx = d_matrix->dx();
double dy = d_matrix->dy();
double x_start = d_matrix->xStart();
double y_start = d_matrix->yStart();
double r = 0.0, c = 0.0;
for(int row = startRow; row <= endRow; row++){
r = row + 1.0;
script->setDouble(r, "i");
script->setDouble(r, "row");
script->setDouble(y_start + row*dy, "y");
int aux = row*d_cols + startCol;
for(int col = startCol; col <= endCol; col++){
c = col + 1.0;
script->setDouble(c, "j");
script->setDouble(c, "col");
script->setDouble(x_start + col*dx, "x");
res = script->eval();
if (res.canConvert(QVariant::Double))
d_data[aux++] = res.toDouble();
else {
QApplication::restoreOverrideCursor();
d_data[aux++] = GSL_NAN;
return false;
}
}
qApp->processEvents();
}
QApplication::restoreOverrideCursor();
return true;
}
void MorphismListWidget::updateList(const VariableList &variableList)
{
// updates morphism list
int row = 0;
int rowSpan = 0;
QTableWidgetItem *nameItem;
QTableWidgetItem *varItem;
clearContents();
VariableListIterator i(variableList);
while (i.hasNext()) {
i.next();
if (i.value().type() == Morphism)
row += i.value().mapData().domainRank();
}
setRowCount(row);
i.toFront();
row = 0;
while (i.hasNext()) {
i.next();
if (i.value().type() == Morphism) {
nameItem = item(row,0);
if (!nameItem) {
nameItem = new QTableWidgetItem;
setItem(row,0,nameItem);
}
nameItem->setText(i.key());
nameItem->setTextAlignment(Qt::AlignLeft);
nameItem->setTextAlignment(Qt::AlignVCenter);
nameItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
rowSpan = i.value().mapData().domainRank();
setSpan(row,0,rowSpan,1);
MapIterator x(i.value().mapData());
while (x.hasNext()) {
x.next();
if (x.key().isLower()) {
varItem = item(row,1);
if (!varItem) {
varItem = new QTableWidgetItem;
setItem(row,1,varItem);
}
varItem->setText(QString(x.key()) + " -> " + x.value());
varItem->setTextAlignment(Qt::AlignLeft);
varItem->setTextAlignment(Qt::AlignVCenter);
varItem->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
row++;
}
}
}
}
}
//resize table and set column headings
void Spreadsheet::clear()
{
setRowCount(0);
setColumnCount(0);
setRowCount(RowCount);
setColumnCount(ColumnCount);
for (int i = 0; i < ColumnCount; ++i)
{
QTableWidgetItem *item = new QTableWidgetItem;
item->setText(QString(QChar('A' + i)));
setHorizontalHeaderItem(i, item);
}
setCurrentCell(0,0);
}
void
AnalysisDataAverageModule::dataStarted(AbstractAnalysisData *data)
{
int nrows = data->columnCount();
setRowCount(nrows);
allocateValues();
nsamples_.resize(nrows);
}
void WidgetTableProgression::initialize(int rows, QString progression) {
m_completing = true;
setRowCount(rows);
setColumnCount(2);
setHorizontalHeaderItem(0, new QTableWidgetItem(NAME_LEVEL));
setHorizontalHeaderItem(1, new QTableWidgetItem(progression));
verticalHeader()->hide();
}
searchTable::searchTable(QWidget *parent): QTableWidget(parent),index(0)
{
setColumnCount(8);
QStringList header;
header<<"Name "<<"Type "<<"LV "<<"MP "<<"HP "<<"Strength "<<"Constitution "<<"Wisdom ";
setHorizontalHeaderLabels(header);
setRowCount(0);
}
void tableTemplateWidget::deleteTemplate(void)
{
if (templateId == 0)
return;
QMessageBox delTmp(QMessageBox::Question,
tr("Deleting template!"),
tr("Do you want delete template ?"),
QMessageBox::Yes | QMessageBox::No);
int code = delTmp.exec();
if (code == QMessageBox::No)
return;
QSqlQuery query;
QSqlError le;
query.prepare("DELETE FROM crossword.private_data WHERE _template = ?;");
query.addBindValue(QVariant(templateId));
query.exec();
le = query.lastError();
if (le.type() != QSqlError::NoError)
qDebug() << "1. deleteTemplate: " << le.text();
query.prepare("DELETE FROM crossword.grids WHERE _template = ?;");
query.addBindValue(QVariant(templateId));
query.exec();
le = query.lastError();
if (le.type() != QSqlError::NoError)
qDebug() << "2. deleteTemplate: " << le.text();
query.prepare("DELETE FROM crossword.templates WHERE _id = ?;");
query.addBindValue(QVariant(templateId));
query.exec();
le = query.lastError();
if (le.type() != QSqlError::NoError)
qDebug() << "3. deleteTemplate: " << le.text();
for (int i = 0; i < numCol; i++)
removeColumn(0);
setRowCount(0);
sb->showMessage(tr("Template deleted"), 2000);
// need for templateListWidget
emit deletedFromDB(templateId);
numCol = numRow = 0;
templateId = 0;
countWords = 0;
wi.clear();
}
//! Creates a new row that matches points.at(row)
void PointTableWidget::createNewRow(int row) {
setRowCount(rowCount() + 1);
QTableWidgetItem * newItem = new QTableWidgetItem(tr("%1").arg(points.at(row).x()));
setItem(row, settings.xColumn, newItem);
newItem = new QTableWidgetItem(tr("%1").arg(points.at(row).y()));
setItem(row, settings.yColumn, newItem);
}
void Foundlist::handleNewData( int i )
{
if( (i == 0) || (mQuery.mEntries.size() == 0) )
{
return;
}
setRowCount( i );
--i;
int playtime = mQuery.mEntries.at(i).playtime / 75;
QString displaytime( QString::number( playtime / 60 ) );
displaytime.append(":");
if( (playtime % 60) < 10 )
{
displaytime.append("0");
}
displaytime.append( QString::number( playtime % 60 ) );
QTableWidgetItem *categoryItem =
new QTableWidgetItem( mQuery.mEntries.at(i).category );
categoryItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 0, categoryItem );
QTableWidgetItem *idItem =
new QTableWidgetItem( mQuery.mEntries.at(i).id );
idItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 1, idItem );
QTableWidgetItem *trackItem =
new QTableWidgetItem( QString::number( mQuery.mEntries.at(i).track ) );
trackItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 2, trackItem );
QTableWidgetItem *titleItem =
new QTableWidgetItem( mQuery.mEntries.at(i).title );
titleItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 3, titleItem );
QTableWidgetItem *playtimeItem =
new QTableWidgetItem( displaytime );
playtimeItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 4, playtimeItem );
#if INCLUDE_EXT
if( mQuery.mEntries.count() > 5 )
{
QTableWidgetItem *extItem =
new QTableWidgetItem( mQuery.mEntries.at(i).ext );
categoryItem->setFlags( Qt::ItemIsSelectable | Qt::ItemIsEnabled );
setItem( i, 5, extItem );
}
#endif
resizeColumnsToContents();
}
/**----------------------------------------------------------------
* Create the output from a single ChebfunWorkspace.
*/
void ChebfunToTable::fromChebWorkspace()
{
ChebfunWorkspace_sptr cws = getClass("InputWorkspace");
Numeric::FunctionDomain1D_sptr domain;
size_t n = (int)get("N");
if (n < 2)
{// if n has default value (0) use the x-points of the chebfuns
domain = cws->fun().createDomainFromXPoints();
n = domain->size();
}
else
{// otherwise create a regular comb
domain = cws->fun().createDomain( n );
}
Numeric::FunctionValues values( *domain );
cws->fun().function(*domain, values);
auto tws = API::TableWorkspace_ptr(dynamic_cast<API::TableWorkspace*>(
API::WorkspaceFactory::instance().create("TableWorkspace"))
);
tws->addColumn("double","X");
tws->addColumn("double","Y");
tws->setRowCount(n);
auto xColumn = static_cast<API::TableColumn<double>*>(tws->getColumn("X").get());
xColumn->asNumeric()->setPlotRole(API::NumericColumn::X);
auto& x = xColumn->data();
auto yColumn = static_cast<API::TableColumn<double>*>(tws->getColumn("Y").get());
yColumn->asNumeric()->setPlotRole(API::NumericColumn::Y);
auto& y = yColumn->data();
for(size_t i = 0; i < domain->size(); ++i)
{
x[i] = (*domain)[i];
y[i] = values.getCalculated(i);
}
bool dropXInf = get("DropXInf");
if ( dropXInf )
{
if ( fabs( x.front() ) == inf )
{
tws->removeRow( 0 );
}
if ( fabs( x.back() ) == inf )
{
tws->removeRow( tws->rowCount() - 1 );
}
}
setProperty("OutputWorkspace",tws);
}
void ParameterTable::initTable()
{
setRowCount(0);
setSelectionMode(QTableWidget::NoSelection);
mpComboDelegate = new CQComboDelegate(NULL, this);
setItemDelegateForColumn(2, mpComboDelegate);
setShowGrid(false);
}
void TableWidget::populateTable(const openstudio::WorkspaceObject& obj)
{
clear();
setCurrentCell(0,0);
setRowCount(1);
openstudio::IddObject iddObj = obj.iddObject();
for(unsigned i=0; i<obj.numFields(); ++i){
bool defaultText = false;
OptionalString val = obj.getString(i);
if(!val){
defaultText = true;
val = obj.getString(i, true);
// if still no value it is just blank
if (!val){
val = "";
}
}
// setItem causes QTableWIdget to take ownership of newItem
QTableWidgetItem * newItem = new QTableWidgetItem((*val).c_str());
if(defaultText){
newItem->setTextColor(Qt::gray);
}
setItem(rowCount()-1, 1, newItem);
openstudio::OptionalIddField iddField = iddObj.getField(i);
if(!iddField){
// log error
}
else{
*val = iddField->name();
}
// setItem causes QTableWIdget to take ownership of newItem
newItem = new QTableWidgetItem((*val).c_str());
setItem(rowCount()-1, 0, newItem);
setRowCount(rowCount() + 1);
}
resizeColumnsToContents();
resizeRowsToContents();
}
MusicFunctionTableWidget::MusicFunctionTableWidget(QWidget *parent)
: MusicAbstractTableWidget(parent)
{
QHeaderView *headerview = horizontalHeader();
headerview->resizeSection(0, 20);
headerview->resizeSection(1, 20);
headerview->resizeSection(2, 85);
setRowCount(3);
m_listIndex = 0;
}
void MailListView::treeInsert(const QMailIdList& idList,
const QSoftMenuBar::StandardLabel label)
{
this->clear();
setRowCount(idList.count());
for(int i = 0; i < idList.count(); ++i) {
setItem(i, 0, new EmailListItem(this, idList[i], 0) );
}
QSoftMenuBar::setLabel(this, Qt::Key_Select, rowCount() ? label : QSoftMenuBar::NoLabel);
}
void SampleList::appendSample(bool read_only, QString name, QString a1, QString a2)
{
//append a row
int idx = rowCount();
setRowCount(idx+1);
//add items to the row
setItem(idx, 0, createItem(read_only, name));
setItem(idx, 1, createItem(read_only, a1));
setItem(idx, 2, createItem(read_only, a2));
}
MyStandardItemModel::MyStandardItemModel(QObject * parent)
:QStandardItemModel(parent)
{
for(int i=0;i<30;i++)
{
flag[i]=0;
}
setRowCount(0);
setColumnCount(0);
}
void TableWidget::insertBlankRow(){
int ind = currentRow()+1;
if(ind==-1){
return;
}
bool enabled = isSortingEnabled();
setSortingEnabled(false);
int n = rowCount();
//QList<int> inds;inds<<0<<1<<2<<5;
QAction *action = qobject_cast<QAction *>(sender());
ColumnType t = static_cast<ColumnType>(action->data().toInt());
QList<int> inds;
if(t==ORIGIN){
inds = originCols_;
qDebug()<<"origin columns";
}else if(t==RESULT){
qDebug()<<"result columns";
inds = resultCols_;
}else{
QMessageBox::critical(this,"","Bug, unknown columntype in TableWidget::insertBlankRow");
return;
}
for(int i=0;i<inds.size();i++){
int col = inds[i];
QList<TableWidgetItem*> tmp;
for(int row=ind;row<n;row++){
tmp << (TableWidgetItem*)takeItem( row, col );
}
int row = ind+1;
for(int j=0;j<tmp.size();j++){
if(row>=rowCount()){
setRowCount(row+1);
setNonEditable( row+1, row+1 );
}
setItem( row, col, tmp.at(j) );
//qDebug()<<i<<j;
row++;
}
//blank item
TableWidgetItem *newItem = new TableWidgetItem;
newItem->setFlags( newItem->flags() &= ~Qt::ItemIsEditable );
setItem( ind, col, newItem );
}
setSortingEnabled(enabled);
//nFiles=nFiles+1;
for(int i=0;i<rowCount();i++){
item(i,CURRENT_TITLE)->setFlags( item(i,CURRENT_TITLE)->flags() &= ~Qt::ItemIsEditable );
item(i,CURRENT_TITLE)->setFlags( item(i,CURRENT_TITLE)->flags() &= ~Qt::ItemIsEditable );
}
}
void tcStockDataItemModel::CreateStockList(int pGroupIndex, const QString &pStockCodeFilter, const QString &pStockNameFilter)
{
mViewStockInfoList.ReloadFromGroupFilter(pGroupIndex, pStockCodeFilter, pStockNameFilter);
//show stock in the tableview
setRowCount(0);
foreach(tcStockInfo info, mViewStockInfoList) {
int row = rowCount();
insertRow(row);
setItem(row, 0, new QStandardItem(info.GetStockCode()));
setItem(row, 1, new QStandardItem(info->GetStockName()));
}
Spreadsheet::Spreadsheet(QWidget *parent):QTableWidget(parent)
{
setItemPrototype(new Cell);
setSelectionMode(ContiguousSelection);
connect(this,SIGNAL(itemChanged(QTableWidgetItem*)),this,SLOT(somethingChanged()));
setRowCount(RowCount);
setColumnCount(ColumnCount);
clear();
}
void MusicMyDownloadRecordWidget::createDownloadItem(const QString &name, qint64 time)
{
setRowCount( rowCount() + 1);
QString musicName = name;
musicName.remove(MUSIC_DOWNLOAD_AL).chop(4);
m_musicRecord.m_names << musicName;
m_musicRecord.m_paths << QFileInfo(name).absoluteFilePath();
m_musicRecord.m_sizes << "0.0M";
createItem(rowCount() - 1, musicName, "0.0M", time);
}
DischargeItemTable::DischargeItemTable(QWidget *parent) :
UiAutoRowTable(parent), _variable(&Rad::EmptyQuantity)
{
setColumnCount(2);
setRowCount(1);
setColumnWidth(0, 120);
setColumnWidth(1, 230);
DischargeItemDelegate * itemDelegate = new DischargeItemDelegate(this);
this->setItemDelegate(itemDelegate);
this->setToolTip(tr("Double click cell to input radionuclide and associated value"));
}
void SensorsList::configurePorts(QStringList const &ports)
{
setRowCount(ports.length());
for (int row = 0; row < ports.length(); ++row) {
setRowHeight(row, 20);
mPortRowMap[ports.at(row)] = row;
setItem(row, 0, new QTableWidgetItem(ports.at(row)));
setItem(row, 1, new QTableWidgetItem(tr("N/A")));
setItem(row, 2, new QTableWidgetItem(tr("N/A")));
}
}
/**-------------------------------------------------
* Make a quadrature given a Polynomial.
* @param P :: A polynomial to use to make the quadrature.
*/
void MakeQuadrature::makeQuadrature(const Polynomial& P)
{
auto& r = P.getRoots();
auto& w = P.getWeights();
const size_t n = r.size();
auto quad = new Quadrature;
quad->setRowCount( int(n) );
quad->addDoubleColumn("r", API::NumericColumn::X);
auto& rc = quad->getDoubleData("r");
rc = r;
quad->addDoubleColumn("w", API::NumericColumn::Y);
auto& wc = quad->getDoubleData("w");
wc = w;
FunctionDomain1DView domain( r );
FunctionValues values( domain );
std::vector<double> wgt;
std::vector<double> wgtDeriv;
P.weightFunction()->function( domain, values );
values.copyToStdVector( wgt );
P.weightDerivative()->function( domain, values );
values.copyToStdVector( wgtDeriv );
quad->addDoubleColumn("weight", API::NumericColumn::Y);
auto& wgtc = quad->getDoubleData("weight");
wgtc = wgt;
quad->addDoubleColumn("deriv", API::NumericColumn::Y);
auto& derc = quad->getDoubleData("deriv");
derc = wgtDeriv;
Quadrature::FuncVector fvec( n );
Quadrature::FuncVector dvec( n );
for(size_t i = 0; i < n; ++i)
{
std::string colInd = boost::lexical_cast<std::string>( i );
quad->addDoubleColumn("f"+colInd, API::NumericColumn::Y);
fvec[i] = &quad->getDoubleData("f"+colInd);
quad->addDoubleColumn("d"+colInd, API::NumericColumn::Y);
dvec[i] = &quad->getDoubleData("d"+colInd);
}
P.calcPolyValues( fvec, dvec );
quad->init();
setClassProperty( "Quadrature", API::TableWorkspace_ptr( quad ) );
{
const double startX = get("StartX");
const double endX = get("EndX");
ChebfunWorkspace_sptr cheb( new ChebfunWorkspace(chebfun( 100, startX, endX )) );
cheb->fun().fit( P );
setClassProperty("ChebWorkspace", cheb);
}
}
void ColMsgTable::refresh()
{
setRowCount(0);
flat_msg_list.clear();
refresh(msgs);
adjustColumn(ABS_RANK_COL);
adjustColumn(HI_RANK_COL);
adjustColumn(FROM_COL);
adjustColumn(TO_COL);
adjustColumn(CMD_COL);
setColumnStretchable(MSG_COL, TRUE);
}
void ModulesInfo::clean()
{
int rows = rowCount();
for (int row = 0; row < rows; row++)
delete cellWidget(0, row);
clear();
setRowCount(0);
m_modules.clear();
m_rows.clear();
setHorizontalHeaderLabels(m_moduleInfo);
}
void PropertyEditingTable::fill(QDomElement xml,
QMap<QString, QString> values) {
QDomNodeList exprops = xml.elementsByTagName("property");
setRowCount(exprops.count());
for (int k = 0; k < exprops.count(); k++) {
QDomElement exprop = exprops.at(k).toElement();
QTableWidgetItem *item;
item = new QTableWidgetItem(exprop.attribute("title"));
QString propDesc = exprop.attribute("description");
item->setFlags(Qt::ItemIsEnabled);
if (!propDesc.isEmpty())
item->setToolTip(propDesc);
setItem(k, 0, item);
QString val = exprop.attribute("default");
QString propKey = exprop.attribute("name");
QString propType = exprop.attribute("type");
if (values.contains(propKey))
val = values[propKey];
PropDesc pdesc;
pdesc.name=propKey;
pdesc.type=propType;
pdesc.value=val;
props.append(pdesc);
if (propType == "boolean") {
QCheckBox *cb = new QCheckBox("");
cb->setChecked(val.toInt() != 0);
if (!propDesc.isEmpty())
cb->setToolTip(propDesc);
setCellWidget(k, 1, cb);
} else {
item = new QTableWidgetItem(val);
if (!propDesc.isEmpty())
item->setToolTip(propDesc);
setItem(k, 1, item);
}
if ((propType == "dir")||(propType == "file")) {
QPushButton *bt = new QPushButton("Browse");
mapper->setMapping(bt, k);
connect(bt, SIGNAL(clicked()), mapper, SLOT(map()));
setCellWidget(k, 2, bt);
}
}
horizontalHeader()->resizeSections(QHeaderView::ResizeToContents);
}
