void SetupPluginsDialog::updatePlugins()
{
FItemElement.clear();
ui.twtPlugins->clearContents();
ui.twtPlugins->setRowCount(0);
QDomElement pluginElem = FPluginsSetup.documentElement().firstChildElement();
while (!pluginElem.isNull())
{
QString name = pluginElem.firstChildElement("name").text().isEmpty() ? pluginElem.tagName() : pluginElem.firstChildElement("name").text();
QTableWidgetItem *nameItem = new QTableWidgetItem(name);
if (pluginElem.attribute("enabled","true")=="true")
{
if (FPluginManager->pluginInstance(pluginElem.attribute("uuid"))==NULL)
nameItem->setForeground(Qt::red);
nameItem->setCheckState(Qt::Checked);
}
else
{
nameItem->setForeground(Qt::gray);
nameItem->setCheckState(Qt::Unchecked);
}
nameItem->setCheckState(pluginElem.attribute("enabled","true")=="true" ? Qt::Checked : Qt::Unchecked);
QTableWidgetItem *fileItem = new QTableWidgetItem(pluginElem.tagName());
ui.twtPlugins->setRowCount(ui.twtPlugins->rowCount()+1);
ui.twtPlugins->setItem(ui.twtPlugins->rowCount()-1, COL_NAME, nameItem);
ui.twtPlugins->setItem(nameItem->row(), COL_FILE, fileItem);
FItemElement.insert(nameItem,pluginElem);
pluginElem = pluginElem.nextSiblingElement();
}
ui.twtPlugins->sortItems(COL_NAME,Qt::AscendingOrder);
}
void MainWindow::busMonitorAddItem( bool isRequest,
uint8_t slave,
uint8_t func,
uint16_t addr,
uint16_t nb,
uint16_t expectedCRC,
uint16_t actualCRC )
{
QTableWidget * bm = ui->busMonTable;
const int rowCount = bm->rowCount();
bm->setRowCount( rowCount+1 );
QTableWidgetItem * ioItem = new QTableWidgetItem( isRequest ? tr( "Req >>" ) : tr( "<< Resp" ) );
QTableWidgetItem * slaveItem = new QTableWidgetItem( QString::number( slave ) );
QTableWidgetItem * funcItem = new QTableWidgetItem( QString::number( func ) );
QTableWidgetItem * addrItem = new QTableWidgetItem( QString::number( addr ) );
QTableWidgetItem * numItem = new QTableWidgetItem( QString::number( nb ) );
QTableWidgetItem * crcItem = new QTableWidgetItem;
if( func > 127 )
{
addrItem->setText( QString() );
numItem->setText( QString() );
funcItem->setText( tr( "Exception (%1)" ).arg( func-128 ) );
funcItem->setForeground( Qt::red );
}
else
{
if( expectedCRC == actualCRC )
{
crcItem->setText( QString().sprintf( "%.4x", actualCRC ) );
}
else
{
crcItem->setText( QString().sprintf( "%.4x (%.4x)", actualCRC, expectedCRC ) );
crcItem->setForeground( Qt::red );
}
}
ioItem->setFlags( ioItem->flags() & ~Qt::ItemIsEditable );
slaveItem->setFlags( slaveItem->flags() & ~Qt::ItemIsEditable );
funcItem->setFlags( funcItem->flags() & ~Qt::ItemIsEditable );
addrItem->setFlags( addrItem->flags() & ~Qt::ItemIsEditable );
numItem->setFlags( numItem->flags() & ~Qt::ItemIsEditable );
crcItem->setFlags( crcItem->flags() & ~Qt::ItemIsEditable );
bm->setItem( rowCount, 0, ioItem );
bm->setItem( rowCount, 1, slaveItem );
bm->setItem( rowCount, 2, funcItem );
bm->setItem( rowCount, 3, addrItem );
bm->setItem( rowCount, 4, numItem );
bm->setItem( rowCount, 5, crcItem );
bm->verticalScrollBar()->setValue( 100000 );
}
//Method to set week days
void MonthView::SetWeekDays()
{
//Headers
int weekDay = 1;
for(int i = 0 ;i < 7;i++)
{
//Set column width
ui->tblHeader->setColumnWidth(i,60);
ui->tblDates->setColumnWidth(i,60);
QTableWidgetItem *item = new QTableWidgetItem();
QString name = QDate::shortDayName(weekDay++);
item->setText(name);
item->setTextAlignment(Qt::AlignTop | Qt::AlignHCenter);
if( i >4)
{
item->setBackgroundColor(QColor::fromRgb(201,72,135));
item->setForeground(QBrush(QColor::fromRgb(136,36,89)));
}
ui->tblHeader->setItem(0,i,item);
}
//Add the column for weekly totals
ui->tblHeader->setColumnWidth(7,120);
ui->tblDates->setColumnWidth(7,120);
QTableWidgetItem *item = new QTableWidgetItem();
item->setText("Weekly Totals");
item->setTextAlignment(Qt::AlignTop | Qt::AlignHCenter);
ui->tblHeader->setItem(0,7,item);
}
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;
}
int TableWidgetItem::setForeground ( lua_State * L )// ( const QBrush & brush )void
{
QTableWidgetItem* lhs = ValueInstaller2<QTableWidgetItem>::check( L, 1 );
QBrush* brush = ValueInstaller2<QBrush>::check( L, 2 );
lhs->setForeground( *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 WidgetTableProgression::updateWithBaseInflation(int base, double inflation,
int maxLevel, QHash<int, int> *subTable)
{
int t = 0, exp;
double pow = 2.4 + inflation / 100.0;
QTableWidgetItem *item;
if (m_totalWidget != nullptr) {
m_totalWidget->setItem(0, 0, new QTableWidgetItem(QString::number(1)));
m_totalWidget->setItem(0, 1, new QTableWidgetItem(QString::number(0)));
}
for (int i = 2; i <= maxLevel; i++) {
exp = qFloor(base * (qPow(i + 3, pow) / qPow(5, pow)));
if (m_totalWidget != nullptr) {
t += exp;
m_totalWidget->setItem(i - 1, 0, new QTableWidgetItem(QString::number(i)));
m_totalWidget->setItem(i - 1, 1, new QTableWidgetItem(QString::number(t)));
}
setItem(i - 2, 0, new QTableWidgetItem(QString::number(i - 1)));
setItem(i - 2, 1, new QTableWidgetItem(QString::number(exp)));
}
// Complete with exp table
if (m_totalWidget != nullptr) {
QHash<int, int>::const_iterator i;
if (subTable != nullptr) {
for (i = subTable->begin(); i != subTable->end(); i++) {
this->item(i.key() - 1, 0)->setText(QString::number(i.value()));
item = this->item(i.key() - 1, 1);
item->setText(QString::number(i.value()));
item->setForeground(SUB_EDITED_COLOR);
}
}
for (i = m_table->begin(); i != m_table->end(); i++) {
this->item(i.key() - 1, 0)->setText(QString::number(i.value()));
item = this->item(i.key() - 1, 1);
item->setText(QString::number(i.value()));
item->setForeground(m_editedColor);
}
if (!m_table->isEmpty() || (subTable != nullptr && !subTable->isEmpty()))
{
updateTotal();
}
}
m_completing = false;
}
void MyIconView::addItem(int &col, int &row, dirEntryT *e){
QTableWidgetItem *item;
item = new QTableWidgetItem(QString::fromStdString(e->name));
item->setIcon(base_icon);
if(e->type == e->Type::DIR){
item->setIcon(dir_icon);
item->setFont(bold_font);
}else if(e->type == e->Type::LINK){
item->setFont(italic_font);
item->setForeground(QBrush(QColor(255, 0, 0)));
}else if(e->type == e->Type::ARCHIVE){
item->setIcon(ar_icon);
item->setFont(bold_font);
item->setForeground(QBrush(QColor(255, 0, 255)));
}else item->setFont(base_font);
setItem(row, col, item);
}
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 UDbScriptAccess::populateTable(int row, int col, QString text, QString textColor)
{
QTableWidgetItem *item = new QTableWidgetItem("");
item->setData(2, text);
item->setForeground(QBrush(QColor(textColor)));
item->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
__tableWidgetEdited->blockSignals(true);
__tableWidgetEdited->setItem(row, col, item);
__tableWidgetEdited->blockSignals(false);
}
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);
}
QTableWidgetItem* IDEWidget::createItem(const QString& text, bool link)
{
QTableWidgetItem* item = new QTableWidgetItem(text);
item->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
if (link) {
item->setForeground(linkBrush);
item->setToolTip(tr("Double click to open file"));
}
return item;
}
void ProcessingManager::addStatusToTable(int processId, ProjectImage* image, const QString& text, bool error) {
QStringList cell = text.split(';');
for(QString s : cell) {
if(!s.trimmed().isEmpty()) {
QTableWidgetItem* idItem = new QTableWidgetItem();
idItem->setFlags(idItem->flags() ^ Qt::ItemIsEditable);
idItem->setText(QString::number(processId));
QTableWidgetItem* imageItem = new QTableWidgetItem();
imageItem->setFlags(imageItem->flags() ^ Qt::ItemIsEditable);
QString imageStr, imageToolTip;
if(image) {
imageStr = image->toString();
imageToolTip = image->workingPath();
}
imageItem->setText(imageStr);
imageItem->setToolTip(imageToolTip);
QTableWidgetItem* processItem = new QTableWidgetItem();
processItem->setFlags(processItem->flags() ^ Qt::ItemIsEditable);
processItem->setText(QTime::currentTime().toString("hh:mm:ss.zzz") + " " + text);
if(error) {
idItem->setForeground(Qt::red);
imageItem->setForeground(Qt::red);
processItem->setForeground(Qt::red);
}
int row = statusEntryTable_->rowCount();
statusEntryTable_->setSortingEnabled(false);
statusEntryTable_->insertRow(row);
statusEntryTable_->setItem(row, 0, idItem);
statusEntryTable_->setItem(row, 1, imageItem);
statusEntryTable_->setItem(row, 2, processItem);
statusEntryTable_->setSortingEnabled(true);
}
}
statusEntryTable_->resizeColumnToContents(0);
statusEntryTable_->resizeColumnToContents(1);
statusEntryTable_->scrollToBottom();
}
void MainWindow::on_pushButton_clicked()
{
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
QString str;
QTableWidgetItem* itm = ui->tableWidget->item( i, j );
if (itm)
{
str = itm->text();
input[i][j]=str.toInt();
output[i][j]=input[i][j];
}
else output[i][j]=input[i][j]=0;
}
}
if(solve(0,0))
{ ui->label->setText("YES");
for(int i=0;i<9;i++)
{
for(int j=0;j<9;j++)
{
QTableWidgetItem *itab;
itab = new QTableWidgetItem; // add this line
QString s = QString::number(output[i][j]);
itab->setText(s);
if(input[i][j]!=0)
{
itab->setForeground(QColor::fromRgb(255,0,0)); //make this item red.
}
ui->tableWidget->setItem(i, j, itab);
}
}
}
else ui->label->setText("NO");
/*
QTableWidgetItem *itab;
itab = new QTableWidgetItem; // add this line
QString s = QString::number(j);
itab->setText(s);
ui->tableWidget->setItem(i, j, itab);
*/
//delete(itab);
}
void WidgetTableProgression::on_cellChanged(int row, int column) {
if (!m_completing && m_table != nullptr) {
if (column == 0) {
item(row, column)->setText(QString::number(row + 1));
} else {
QString value = item(row, column)->text();
int correctedValue = value.toInt();
QTableWidgetItem *itemProgression = item(row, 1);
itemProgression->setText(QString::number(correctedValue));
itemProgression->setForeground(m_editedColor);
m_table->insert(row + 1, correctedValue);
updateTotal();
}
}
}
void HgPullDialog::parseUpdateChanges(const QString &input)
{
QStringList list = input.split(" ", QString::SkipEmptyParts);
QTableWidgetItem *author = new QTableWidgetItem;
QTableWidgetItem *changeset = new QTableWidgetItem;
QTableWidgetItem *date = new QTableWidgetItem;
QTableWidgetItem *summary = new QTableWidgetItem;
author->setForeground(Qt::darkRed);
changeset->setForeground(Qt::red);
date->setForeground(Qt::blue);
author->setText(list.takeFirst());
changeset->setText(list.takeFirst());
date->setText(list.takeFirst());
summary->setText(list.takeFirst());
int rowCount = m_changesList->rowCount();
m_changesList->insertRow(rowCount);
m_changesList->setItem(rowCount, 0, author);
m_changesList->setItem(rowCount, 1, changeset);
m_changesList->setItem(rowCount, 2, date);
m_changesList->setItem(rowCount, 3, summary);
}
//-----------------------------------------------------------------------------
void ChannelSelectionDialog::on_channel_table__cellChanged (int row, int column)
{
if (column == VISIBLE_INDEX_)
{
if (!self_setting_)
{
self_setting_ = true;
QTableWidgetItem* item = ui_.channel_table_->item (row, column);
if (item->checkState() == Qt::Checked)
item->setCheckState (Qt::Unchecked);
else
item->setCheckState (Qt::Checked);
}
bool all_visible = true;
bool all_hidden = true;
for (int row_index = 0; row_index < ui_.channel_table_->rowCount(); ++row_index)
{
QTableWidgetItem* item = ui_.channel_table_->item (row_index, VISIBLE_INDEX_);
if (!item)
return;
if (item->checkState() == Qt::Checked)
{
all_hidden = false;
item->setForeground (VISIBLE_COLOR_);
}
else
{
all_visible = false;
item->setForeground (NOT_VISIBLE_COLOR_);
}
}
ui_.select_all_button_->setDisabled (all_visible);
ui_.unselect_all_button_->setDisabled (all_hidden);
ui_.button_box_->button (QDialogButtonBox::Ok)->setDisabled (all_hidden);
}
}
void GraphPlotDialog::addNewGraphToUI(unsigned graphId)
{
QTableWidgetItem* graphItem = new QTableWidgetItem(QString::fromStdString(mData[graphId].name));
graphItem->setData(Qt::UserRole, QVariant(graphId));
setItemColor(graphItem);
int rowCount = mUi.visibleGraph->rowCount();
mUi.visibleGraph->setRowCount(rowCount + 1);
mUi.visibleGraph->setItem(rowCount, 0, graphItem);
QTableWidgetItem* valueItem = new QTableWidgetItem();
valueItem->setForeground(graphItem->foreground());
valueItem->setData(Qt::UserRole, QVariant(graphId));
mUi.visibleGraph->setItem(rowCount, 1, valueItem);
}
void GUI::MainWindow::slotFilter()
{
ui->tbl_Overview->clearContents();
logic::transaction filterTrans;
filterTrans.setDate_from(ui->date_from->date().toString("yyyy-MM-dd"));
filterTrans.setDate_to(ui->date_to->date().toString("yyyy-MM-dd"));
filterTrans.setUserID(1);
filterTrans.setIndex(ui->cmb_DataCount->currentText().toInt());
filterTrans.setCategory(ui->cmb_Cat->currentText() == "<none>" ? "" : ui->cmb_Cat->currentText());
household->retrieveTrans(filterTrans, dataset);
ui->tbl_Overview->setRowCount(dataset.size());
logic::transaction buffer;
QListIterator<logic::transaction> dataIterator(dataset);
QTableWidgetItem *qTableWidgetItem;
int i = 0;
while(dataIterator.hasNext())
{
buffer = dataIterator.next();
qTableWidgetItem = new QTableWidgetItem(buffer.getReason());
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 0, qTableWidgetItem);
qTableWidgetItem = new QTableWidgetItem(buffer.getComment());
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 1, qTableWidgetItem);
qTableWidgetItem = new QTableWidgetItem(QDate::fromString( buffer.getDate(),"yyyy-MM-dd").toString());
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 2, qTableWidgetItem);
qTableWidgetItem = new QTableWidgetItem(buffer.getCategory());
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 3, qTableWidgetItem);
qTableWidgetItem = new QTableWidgetItem(buffer.getPayment_Method());
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 4, qTableWidgetItem);
qTableWidgetItem = new QTableWidgetItem(QString::number(buffer.getValue()));
qTableWidgetItem->setForeground(QBrush(buffer.getValue() > 0 ? QColor(0,255,0) : QColor(255,0,0)));
qTableWidgetItem->setFlags(Qt::ItemIsEnabled | Qt::ItemIsSelectable);
ui->tbl_Overview->setItem(i, 5, qTableWidgetItem);
i++;
}
}
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();
}
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);
QwtDoubleInterval range = QwtDoubleInterval(min_val, max_val);
for (int i = 0; i < rows; i++){
DoubleSpinBox *sb = new DoubleSpinBox();
sb->setLocale(d_locale);
sb->setDecimals(d_precision);
sb->setValue(min_val + colors[i] * range.width());
if (i == 0)
sb->setRange(min_val, min_val);
else if (i == rows -1)
sb->setRange(max_val, max_val);
else
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(i, 0, sb);
QColor c = QColor(map.rgb(QwtDoubleInterval(0, 1), colors[i]));
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(i, 1, it);
}
table->blockSignals(false);
color_map = map;
}
void MainWindow::showParameterStatistic( const QVector<PlotSettings> &v_PS )
{
setMainWindowWidget( _SHOWPARAMETERTABLE_ );
if ( b_showGraphicMinMax == true )
ParameterTable->setColumnCount( 10 );
else
ParameterTable->setColumnCount( 7 );
ParameterTable->setRowCount( v_PS.count() + 1 );
ParameterTable->setSortingEnabled( false );
ParameterTable->setWordWrap( false );
ParameterTable->setCornerButtonEnabled( false );
ParameterTable->verticalHeader()->hide();
ParameterTable->horizontalHeader()->hide();
QTableWidgetItem *ParameterNameHeader = new QTableWidgetItem( tr( "Parameter name" ) );
ParameterNameHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 0, ParameterNameHeader );
QTableWidgetItem *DataMinimumHeader = new QTableWidgetItem( tr( "Minimum" ) );
DataMinimumHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 1, DataMinimumHeader );
QTableWidgetItem *DataMaximumHeader = new QTableWidgetItem( tr( "Maximum" ) );
DataMaximumHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 2, DataMaximumHeader );
QTableWidgetItem *DataMedianHeader = new QTableWidgetItem( tr( "Median" ) );
DataMedianHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 3, DataMedianHeader );
QTableWidgetItem *DataMeanHeader = new QTableWidgetItem( tr( "Mean" ) );
DataMeanHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 4, DataMeanHeader );
QTableWidgetItem *DataStdDevHeader = new QTableWidgetItem( tr( "Std dev" ) );
DataStdDevHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 5, DataStdDevHeader );
QTableWidgetItem *DataTypeHeader = new QTableWidgetItem( tr( "Type" ) );
DataTypeHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 6, DataTypeHeader );
QTableWidgetItem *GraphMinimumHeader = new QTableWidgetItem( tr( "Minimum, graph" ) );
GraphMinimumHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 7, GraphMinimumHeader );
QTableWidgetItem *GraphMaximumHeader = new QTableWidgetItem( tr( "Maximum, graph" ) );
GraphMaximumHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 8, GraphMaximumHeader );
QTableWidgetItem *TickMarkSpacingHeader = new QTableWidgetItem( tr( "Tick mark spacing" ) );
TickMarkSpacingHeader->setBackground( QBrush( Qt::lightGray ) );
ParameterTable->setItem( 0, 9, TickMarkSpacingHeader );
ParameterTable->setColumnWidth( 0, 300 );
ParameterTable->setColumnWidth( 1, 110 );
ParameterTable->setColumnWidth( 2, 110 );
ParameterTable->setRowHeight( 0, 20 );
for( int i=0; i<v_PS.count(); i++ )
{
QTableWidgetItem *Parameter = new QTableWidgetItem( v_PS.at( i ).Parameter() );
ParameterTable->setItem( i+1, 0, Parameter );
if ( v_PS.at( i ).Type() == isDateTime )
{
QTableWidgetItem *Minimum = new QTableWidgetItem( QString( "%1" ).arg( QDate::fromJulianDay( (int) v_PS.at( i ).YMinimum() ).toString( Qt::ISODate ) ) );
ParameterTable->setItem( i+1, 1, Minimum );
QTableWidgetItem *Maximum = new QTableWidgetItem( QString( "%1" ).arg( QDate::fromJulianDay( (int) v_PS.at( i ).YMaximum() ).toString( Qt::ISODate ) ) );
ParameterTable->setItem( i+1, 2, Maximum );
QTableWidgetItem *Type = new QTableWidgetItem( "Date/Time" );
ParameterTable->setItem( i+1, 6, Type );
}
else
{
if ( v_PS.at( i ).Type() != isText )
{
if ( v_PS.at( i ).YMinimum() < 10E99 )
{
QTableWidgetItem *Minimum = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).YMinimum() ) );
ParameterTable->setItem( i+1, 1, Minimum );
}
if ( v_PS.at( i ).YMaximum() > -10E99 )
{
QTableWidgetItem *Maximum = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).YMaximum() ) );
ParameterTable->setItem( i+1, 2, Maximum );
}
if ( v_PS.at( i ).isGeocode() == false )
{
if ( v_PS.at( i ).Median() != -999. )
{
QTableWidgetItem *Median = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).Median() ) );
ParameterTable->setItem( i+1, 3, Median );
}
if ( v_PS.at( i ).Mean() != -999. )
{
QTableWidgetItem *Mean = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).Mean() ) );
ParameterTable->setItem( i+1, 4, Mean );
}
if ( v_PS.at( i ).StandardDeviation() != -999. )
{
QTableWidgetItem *StdDev = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).StandardDeviation() ) );
ParameterTable->setItem( i+1, 5, StdDev );
}
}
}
if ( v_PS.at( i ).Type() == isNumeric )
{
QTableWidgetItem *TypeNumeric = new QTableWidgetItem( "Numeric" );
ParameterTable->setItem( i+1, 6, TypeNumeric );
}
if ( v_PS.at( i ).Type() == isText )
{
QTableWidgetItem *TypeText = new QTableWidgetItem( "Text" );
ParameterTable->setItem( i+1, 6, TypeText );
}
if ( b_showGraphicMinMax == true )
{
QTableWidgetItem *GraphMinimum = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).YGraphMin() ) );
ParameterTable->setItem( i+1, 7, GraphMinimum );
QTableWidgetItem *GraphMaximum = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).YGraphMax() ) );
ParameterTable->setItem( i+1, 8, GraphMaximum );
QTableWidgetItem *TickMarkSpacing = new QTableWidgetItem( QString( "%1" ).arg( v_PS.at( i ).YTickmarkSpacing() ) );
ParameterTable->setItem( i+1, 9, TickMarkSpacing );
}
}
if ( v_PS.at( i ).isGeocode() == true )
Parameter->setForeground( QBrush( Qt::red ) );
ParameterTable->setRowHeight( i+1, 20 );
}
}
void MainWindow::setCurrentSession(QListWidgetItem * item)
{
if (item == NULL) { return; }
selectSessionItem(item);
Session * session;
if (item->listWidget() == SVLSListWidget) {
session = current_db_sessions.value(item->data(Qt::UserRole).toDateTime());
} else if (item->listWidget() == SVLASListWidget) {
session = current_db_archivedsessions.value(item->data(Qt::UserRole).toDateTime());
} else { return; }
current_db_session = session;
SVSelectedSessionWidget->setEnabled(true);
SVNameLabel->setText(session->name());
SVDateTimeLabel->setText(session->dateTimeToString());
SVPassMarkLabel->setText(QString::number(session->passMark().passMark()));
SVOverallResultsProgressBar->setMaximum((int)session->maximumScore());
SVOverallResultsProgressBar->setValue(session->score() > 0 ? (int)session->score() : 0);
SVOverallResultsLabel->setText(QString("%1%").arg(session->average()));
current_db_students.clear();
SVLCListWidget->clear(); SVLogListWidget->clear();
for (int i = 0; i < session->numLogEntries(); ++i) {
QListWidgetItem * log_entry = new QListWidgetItem (session->logEntry(i).entryText(), SVLogListWidget);
log_entry->setBackground(QBrush(session->logEntry(i).entryBackgroundColour()));
log_entry->setForeground(QBrush(session->logEntry(i).entryForegroundColour()));
}
SVLogGroupBox->setVisible(session->numLogEntries() > 0);
for (int i = 0; i < session->numStudents(); ++i) {
QListWidgetItem * item = new QListWidgetItem(session->student(i)->name(), SVLCListWidget);
current_db_students.insert(item, session->student(i));
if (session->student(i)->passed()) {
item->setBackground(QBrush(QColor(197, 255, 120)));
} else {
item->setBackground(QBrush(QColor(204, 163, 0)));
}
item->setForeground(QBrush(QColor(0, 0, 0)));
}
SVPassMarkTableWidget->clearContents();
SVPassMarkTableWidget->verticalHeader()->hide();
if (session->passMark().count() > 0) {
passMarkDetailsTab->setEnabled(true); QTableWidgetItem * item;
SVPassMarkTableWidget->setRowCount(session->passMark().count());
for (int i = 0; i < session->passMark().count(); ++i) {
if (session->passMark().condition(i) < 0 || session->passMark().condition(i) >= current_db_f.size()) { continue; }
item = new QTableWidgetItem(QString("%1 - %2").arg(session->passMark().condition(i) + 1).arg(current_db_f[session->passMark().condition(i)]));
item->setBackground(QBrush(backgroundColourForFlag(session->passMark().condition(i))));
item->setForeground(QBrush(foregroundColourForFlag(session->passMark().condition(i))));
SVPassMarkTableWidget->setItem(i, 0, item);
item = new QTableWidgetItem(QString::number(session->passMark().value(i)));
SVPassMarkTableWidget->setItem(i, 1, item);
SVPassMarkTableWidget->setRowHeight(i, 16);
}
SVPassMarkTableWidget->filterItems(SVSearchDetailsLineEdit, SVSearchDetailsLineEdit->text());
SVStudentTabWidget->setCurrentIndex(1);
} else {
passMarkDetailsTab->setEnabled(false);
SVStudentTabWidget->setCurrentIndex(0);
}
selectedStudentTab->setEnabled(false);
scoringSystemTab->setEnabled(true);
SVScoringSystemTableWidget->item(0, 1)->setText(session->scoringSystem().allowIncompleteAnswers ? tr("allowed") : tr("disallowed"));
for (int i = 0, n = 0; i < 3; ++i, n += 3) {
SVScoringSystemTableWidget->item(n + 1, 1)->setText(QString::number(session->scoringSystem().correctAnswer[i]));
SVScoringSystemTableWidget->item(n + 2, 1)->setText(QString::number(session->scoringSystem().incorrectAnswer[i]));
SVScoringSystemTableWidget->item(n + 3, 1)->setText(QString::number(session->scoringSystem().missingAnswer[i]));
}
SVLCGroupBox->setEnabled(true); SVLogGroupBox->setEnabled(true);
togglePrintEnabled(); enableSVTools();
}
void AppearancePreferences::reset()
{
QSettings settings;
// Empty this
_ui->programTokenTable->clear();
// Declare some variables which will be used to populate the table
QTextCharFormat format;
QTableWidgetItem *item;
int row = 0;
int column = 0;
QStringList headers;
headers << "Token" << "Font" << "Foreground" << "Background";
_ui->programTokenTable->setHorizontalHeaderLabels(headers);
QVector<int> tokens;
// Default, identifiers, declaration identifiers, operators, keywords,
// comments and errors
tokens << ProgramLexeme_Default << ProgramLexeme_Identifier << ProgramLexeme_Declaration << ProgramLexeme_DeclarationOperator
<< ProgramLexeme_Keyword << ProgramLexeme_Comment << ProgramLexeme_Error;
_ui->programTokenTable->setRowCount(tokens.count());
for(row = 0; row < tokens.count(); ++row)
{
format = _ui->plainTextEdit->highlighter()->format(tokens.at(row));
for(column = 0; column < 4; ++column)
{
item = new QTableWidgetItem();
switch(column)
{
case 0:
// The name of this token type
switch(tokens.at(row))
{
case ProgramLexeme_Default:
item->setText("Default");
break;
case ProgramLexeme_Identifier:
item->setText("Identifiers");
break;
case ProgramLexeme_Declaration:
item->setText("Macro Declarations");
break;
case ProgramLexeme_DeclarationOperator:
item->setText("Operators");
break;
case ProgramLexeme_Keyword:
item->setText("Keywords");
break;
case ProgramLexeme_Comment:
item->setText("Comments");
break;
case ProgramLexeme_Error:
item->setText("Errors");
break;
default:
qDebug() << "Unknown token type encountered in "
"AppearancePreferences::reset(), passed "
<< tokens.at(row);
break;
}
item->setFlags(Qt::ItemIsSelectable);
item->setFont(format.font());
item->setForeground(format.foreground());
item->setBackground(format.background());
break;
case 1:
// The font
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEnabled);
item->setText(format.font().family() + ", "
+ QVariant(format.fontPointSize()).toString());
break;
case 2:
// The foreground colour
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable
| Qt::ItemIsEnabled);
item->setText(QVariant(format.foreground().color()).toString());
break;
case 3:
// The background colour
item->setFlags(Qt::ItemIsSelectable | Qt::ItemIsEditable
| Qt::ItemIsEnabled);
item->setText(QVariant(format.background().color()).toString());
break;
default:
qDebug() << "Unexpected column ID in "
"AppearancePreferences::reset(), passed " << column;
break;
}
_ui->programTokenTable->setItem(row, column, item);
}
}
// Now have the table rejig to fit the items it now contains
_ui->programTokenTable->resizeColumnsToContents();
}
void KFFWin_Flightplan::setNavaids( NavaidsData & data )
{
QTableWidgetItem* item = 0;
QString buffer;
QBrush black( QColor( 0, 0, 0, 255 ) );
QBrush grey( QColor( 200, 200, 200, 255 ) );
QBrush *brush;
if ( m_editing )
{
//ui_widget.tableWidget_data->setEnabled( false );
brush = &grey;
ui_widget.kpushbutton_previous->setEnabled( false );
ui_widget.kpushbutton_next->setEnabled( false );
ui_widget.spinbox_altitude->setValue( data.altitude );
ui_widget.pushbutton_add->setText( i18n( "Update" ) );
}
else
{
//ui_widget.tableWidget_data->setEnabled( true );
brush = &black;
ui_widget.pushbutton_add->setText( i18n( "Add" ) );
}
brush->setStyle( Qt::NoBrush );
item = ui_widget.tableWidget_data->item( 0, 0 );
if ( !item )
{
qDebug() << "No item";
return;
}
item->setForeground( *brush );
item->setText( data.id );
item = ui_widget.tableWidget_data->item( 1, 0 );
if ( !item )
{
qDebug() << "No name item";
return;
}
item->setForeground( *brush );
item->setText( data.name );
item = ui_widget.tableWidget_data->item( 3, 0 );
item->setForeground( *brush );
item->setText( data.type );
if ( data.type.contains( "ndb", Qt::CaseInsensitive ) )
{
buffer.setNum( data.frequency, 'f', 0 );
buffer.append( " kHz" );
}
else
{
buffer.setNum( data.frequency, 'f', 2 );
buffer.append( " MHz" );
}
item = ui_widget.tableWidget_data->item( 2, 0 );
item->setForeground( *brush );
item->setText( buffer );
buffer.clear();
buffer.setNum( data.longitude, 'f', 6 );
item = ui_widget.tableWidget_data->item( 4, 0 );
item->setForeground( *brush );
item->setText( buffer );
buffer.clear();
buffer.setNum( data.latitude, 'f', 6 );
item = ui_widget.tableWidget_data->item( 5, 0 );
item->setForeground( *brush );
item->setText( buffer );
}
int BTCTrader::gotReply ( QNetworkReply* reply )
{
/* if ( graph == NULL )
{
// timerOrders->start ( poolInterval );
return 0;
}*/
QByteArray result;
float bid = 0;
float ask = 0;
float trade = 0;
result = reply->readAll ();
QScriptValue sc;
QScriptEngine engine;
sc = engine.evaluate("(" + QString(result) + ")");
if (sc.property("asks").isArray())
{
QStringList items;
qScriptValueToSequence(sc.property("asks"), items);
QMap<float,float> hash;
for ( int i=0;i<items.count();i++ )
{
if ( hash[items.at ( i ).split ( ',') .at ( 0 ).toFloat()] > 0 )
{
hash[items.at ( i ).split ( ',') .at ( 0 ).toFloat()] += items.at ( i ).split ( ',') .at ( 1 ).toFloat();
} else {
hash.insert( items.at ( i ).split ( ',') .at ( 0 ).toFloat(), items.at ( i ).split ( ',') .at ( 1 ).toFloat() );
}
}
QList<float> keys = hash.keys();
qSort ( keys );
ask = keys.at ( 0 );
float balanceBs = 0;
float count = balanceUSD;
int counter = 0;
while ( count > 0 )
{
if ( count >= hash[keys.at ( counter )]*keys.at ( counter ) )
{
balanceBs += hash[keys.at ( counter )];
count -= hash[keys.at ( counter )]*keys.at ( counter );
} else {
balanceBs += count/keys.at ( counter );
count = 0;
}
counter++;
}
balanceBs -= balanceBs/100*fee;
// ui->USDLabel->setText( QString::number ( balanceUSD ) );
// ui->USDtoBTCLabel->setText (QString::number ( balanceBs ) );
if ( graph != NULL )
graph->updateAsk( ask );
if ( ordersGraph != NULL )
ordersGraph->updateAsks( hash );
if ( tradeList != NULL )
{
for ( int i=9; i>=0;i-- )
{
QTableWidgetItem* item;
item = tradeList->takeItem ( i, 0 );
ask = (float)keys.at ( 9 - i );
item->setText( QString::number ( ask ) );
item->setForeground( Qt::red );
tradeList->setItem ( i, 0, item );
item = tradeList->takeItem ( i, 1 );
ask = (float)hash.value( keys.at ( 9 - i ) );
item->setText( QString::number ( ask ) );
tradeList->setItem ( i, 1, item );
}
}
}
if (sc.property("bids").isArray())
{
QStringList items;
qScriptValueToSequence(sc.property("bids"), items);
QMap<float,float> hash;
for ( int i=0;i<items.count();i++ )
{
if ( hash[items.at ( i ).split ( ',') .at ( 0 ).toFloat()] > 0 )
{
hash[items.at ( i ).split ( ',') .at ( 0 ).toFloat()] += items.at ( i ).split ( ',') .at ( 1 ).toFloat();
} else {
hash.insert( items.at ( i ).split ( ',') .at ( 0 ).toFloat(), items.at ( i ).split ( ',') .at ( 1 ).toFloat() );
}
}
QList<float> keys = hash.keys();
qSort ( keys );
bid = keys.at ( keys.count() - 1 );
float balanceBs = 0;
float count = balance;
count -= count / 100 * fee;
int counter = keys.count() - 1;
while ( count > 0 )
{
if ( count >= hash[keys.at ( counter )] )
{
balanceBs += hash[keys.at ( counter )] * keys.at ( counter );
count -= hash[keys.at ( counter ) ];
} else {
balanceBs += count * keys.at ( counter );
count = 0;
}
counter--;
}
// ui->BTCLabel->setText( QString::number ( balance ) );
// ui->BTCtoUSDLabel->setText (QString::number ( balanceBs ) );
if ( graph != NULL )
graph->updateBid( bid );
if ( ordersGraph != NULL )
ordersGraph->updateBids( hash );
if ( tradeList != NULL )
{
for ( int i=11; i<=20;i++ )
{
QTableWidgetItem* item;
item = tradeList->takeItem ( i, 0 );
bid = (float)keys.at ( keys.count() - i + 10 );
item->setText( QString::number ( bid ) );
item->setForeground( Qt::blue );
tradeList->setItem ( i, 0, item );
item = tradeList->takeItem ( i, 1 );
bid = (float)hash.value( keys.at ( keys.count() - i + 10 ) );
item->setText( QString::number ( bid ) );
tradeList->setItem ( i, 1, item );
}
}
timerDepth->start ( poolInterval );
}
if ( sc.property ( "ticker" ).isObject() )
{
QString str = sc.property("ticker").property("last").toString();
trade = str.toFloat ();
graph->updateTrade( trade );
if ( tradeList != NULL )
{
QTableWidgetItem* item;
item = tradeList->takeItem ( 10, 0 );
item->setText( str );
item->setForeground( Qt::green );
tradeList->setItem ( 10, 0, item );
}
// QTableWidgetItem* item;
// item = ui->bidTableWidget->takeItem ( 0, 20 );
// item->setText( str );
// item->setForeground( Qt::green );
// ui->bidTableWidget->setItem ( 0, 20, item );
timerTicker->start ( poolInterval );
}
if ( sc.property ( "usds" ).isString() )
{
balanceUSD=sc.property ( "usds" ).toNumber();
}
if ( sc.property ( "btcs" ).isString() )
{
balance = sc.property ( "btcs" ).toNumber();
}
if ( sc.property ( "orders" ).isObject()/* && ! myOrderTableWidget->contextMenu->isVisible()*/ )
{
errorCount = 0;
// myOrderTableWidget->clear();
// myOrderTableWidget->setRowCount( 0 );
// myOrderTableWidget->setColumnCount( 4 );
QScriptValueIterator iterator ( sc.property( "orders" ) );
while ( iterator.hasNext() )
{
iterator.next();
QTableWidgetItem* item;
// myOrderTableWidget->insertRow( 0 );
item = new QTableWidgetItem ();
item->setText( iterator.value().property( "oid" ).toString() );
if ( iterator.value().property ( "status" ).toInteger() != 1 )
item->setBackgroundColor( ( QColor ( Qt::gray ) ) );
// myOrderTableWidget->setItem( 0, 0, item );
item = new QTableWidgetItem ();
if ( iterator.value().property( "type" ).toInteger() == 1 )
item->setText( "S" );
else
item->setText( "B" );
if ( iterator.value().property ( "status" ).toInteger() != 1 )
item->setBackgroundColor( ( QColor ( Qt::gray ) ) );
// myOrderTableWidget->setItem( 0, 1, item );
item = new QTableWidgetItem ();
item->setText( iterator.value().property( "amount" ).toString() );
if ( iterator.value().property ( "status" ).toInteger() != 1 )
item->setBackgroundColor( ( QColor ( Qt::gray ) ) );
// myOrderTableWidget->setItem( 0, 2, item );
item = new QTableWidgetItem ();
item->setText( iterator.value().property( "price" ).toString() );
if ( iterator.value().property ( "status" ).toInteger() != 1 )
item->setBackgroundColor( ( QColor ( Qt::gray ) ) );
// myOrderTableWidget->setItem( 0, 3, item );
// myOrderTableWidget->setRowHeight(0, 15);
}
/* myOrderTableWidget->removeRow( 0 );*/
/* myOrderTableWidget->setColumnWidth( 0, 0 );
myOrderTableWidget->setColumnWidth( 1, 20 );
myOrderTableWidget->setColumnWidth( 2, 110 );
myOrderTableWidget->setColumnWidth( 3, 110 );*/
timerOrders->start( poolInterval );
}
if ( sc.property( "error" ).toString().length() > 0 )
{
errorCount += 1;
qDebug ( QString ( result ).toStdString().c_str() );
if ( errorCount == 5 )
{
failedLogin = true;
qDebug ( sc.property( "error" ).toString().toStdString().c_str() );
// this->ui->statusBar->showMessage ( sc.property( "error" ).toString() );
// this->setWindowTitle( "BTCTrade - failed login" );
}
}
reply->deleteLater();
return 0;
}
bool CQFittingResult::enterProtected()
{
assert(CCopasiRootContainer::getDatamodelList()->size() > 0);
CCopasiDataModel* pDataModel = (*CCopasiRootContainer::getDatamodelList())[0];
assert(pDataModel != NULL);
mpTask =
dynamic_cast<CFitTask *>((*pDataModel->getTaskList())["Parameter Estimation"]);
if (!mpTask) return false;
mpProblem = dynamic_cast<const CFitProblem *>(mpTask->getProblem());
if (!mpProblem) return false;
mpMain->load(mpProblem);
if (mpProblem->getCalculateStatistics())
{
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpExperiments), true);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpValues), true);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCorrelations), true);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpFisherInformation), true);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidations), true);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidationValues), true);
}
else
{
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpExperiments), false);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpValues), false);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCorrelations), false);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpFisherInformation), false);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidations), false);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidationValues), false);
}
size_t i, imax;
QTableWidgetItem * pItem;
// Loop over the optimization items
const std::vector< COptItem * > & Items = mpProblem->getOptItemList();
const CVector< C_FLOAT64 > & Solutions = mpProblem->getSolutionVariables();
const CVector< C_FLOAT64 > & StdDeviations = mpProblem->getVariableStdDeviations();
const CVector< C_FLOAT64 > & Gradients = mpProblem->getVariableGradients();
imax = Items.size();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
//the parameters table
mpParameters->setRowCount((int) imax);
QColor BackgroundColor = mpParameters->palette().brush(QPalette::Active, QPalette::Base).color();
int h, s, v;
BackgroundColor.getHsv(&h, &s, &v);
if (s < 20)
{
s = 20;
}
BackgroundColor.setHsv(0, s, v);
for (i = 0; i != imax; i++)
{
//1st column: parameter name
const CCopasiObject *pObject =
pDataModel->getDataObject(Items[i]->getObjectCN());
if (pObject)
{
std::string Experiments =
static_cast<CFitItem *>(Items[i])->getExperiments();
if (Experiments != "")
Experiments = "; {" + Experiments + "}";
pItem = new QTableWidgetItem(FROM_UTF8(pObject->getObjectDisplayName() + Experiments));
}
else
pItem = new QTableWidgetItem("Not Found");
mpParameters->setItem((int) i, 0, pItem);
const C_FLOAT64 & Solution = i < Solutions.size() ? Solutions[i] : std::numeric_limits<double>::quiet_NaN();
//2nd column: lower bound
const COptItem *current = Items[i];
pItem = new QTableWidgetItem(FROM_UTF8(current->getLowerBound()));
mpParameters->setItem((int) i, 1, pItem);
if (current->getLowerBoundValue() != NULL && 1.01 * *current->getLowerBoundValue() > Solution)
{
pItem->setBackgroundColor(BackgroundColor);
}
//3rd column: start value
pItem = new QTableWidgetItem(QString::number(current->getStartValue()));
pItem->setForeground(QColor(120, 120, 140));
mpParameters->setItem((int) i, 2, pItem);
//4th column: solution value
pItem = new QTableWidgetItem(QString::number(Solution));
mpParameters->setItem((int) i, 3, pItem);
//5th column: upper bound
pItem = new QTableWidgetItem(FROM_UTF8(current->getUpperBound()));
mpParameters->setItem((int) i, 4, pItem);
if (current->getUpperBoundValue() != NULL && 0.99 * *current->getUpperBoundValue() < Solution)
{
pItem->setBackgroundColor(BackgroundColor);
}
const C_FLOAT64 & StdDeviation = i < StdDeviations.size() ? StdDeviations[i] : std::numeric_limits<double>::quiet_NaN();
pItem = new QTableWidgetItem(QString::number(StdDeviation));
mpParameters->setItem((int) i, 5, pItem);
pItem = new QTableWidgetItem(QString::number(fabs(100.0 * StdDeviation / Solution)));
mpParameters->setItem((int) i, 6, pItem);
pItem = new QTableWidgetItem(QString::number(i < Gradients.size() ? Gradients[i] : std::numeric_limits<double>::quiet_NaN()));
mpParameters->setItem((int) i, 7, pItem);
}
mpParameters->resizeColumnsToContents();
mpParameters->resizeRowsToContents();
// Loop over the experiments
const CExperimentSet & Experiments = mpProblem->getExperiementSet();
imax = Experiments.getExperimentCount();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
mpExperiments->setRowCount((int) imax);
for (i = 0; i != imax; i++)
{
const CExperiment & Experiment = * Experiments.getExperiment(i);
pItem = new QTableWidgetItem(FROM_UTF8(Experiment.getObjectName()));
mpExperiments->setItem((int) i, 0, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getObjectiveValue()));
mpExperiments->setItem((int) i, 1, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getRMS()));
mpExperiments->setItem((int) i, 2, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getErrorMean()));
mpExperiments->setItem((int) i, 3, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getErrorMeanSD()));
mpExperiments->setItem((int) i, 4, pItem);
}
mpExperiments->resizeColumnsToContents();
mpExperiments->resizeRowsToContents();
// Loop over the dependent objects
imax = Experiments.getDependentObjects().size();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
mpValues->setRowCount((int) imax);
for (i = 0; i != imax; i++)
{
const CCopasiObject * pObject = Experiments.getDependentObjects()[i];
if (pObject)
pItem = new QTableWidgetItem(FROM_UTF8(pObject->getObjectDisplayName()));
else
pItem = new QTableWidgetItem("Not Found");
mpValues->setItem((int) i, 0, pItem);
pItem = new QTableWidgetItem(QString::number(Experiments.getDependentObjectiveValues()[i]));
mpValues->setItem((int) i, 1, pItem);
pItem = new QTableWidgetItem(QString::number(Experiments.getDependentRMS()[i]));
mpValues->setItem((int) i, 2, pItem);
pItem = new QTableWidgetItem(QString::number(Experiments.getDependentErrorMean()[i]));
mpValues->setItem((int) i, 3, pItem);
pItem = new QTableWidgetItem(QString::number(Experiments.getDependentErrorMeanSD()[i]));
mpValues->setItem((int) i, 4, pItem);
}
mpValues->resizeColumnsToContents();
mpValues->resizeRowsToContents();
// Fill correlation matrix
imax = Items.size();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
CColorScaleBiLog * tcs = new CColorScaleBiLog();
mpCorrelations->setColorCoding(tcs);
mpCorrelations->setColorScalingAutomatic(true);
mpCorrelations->setArrayAnnotation(&mpProblem->getCorrelations());
tcs = new CColorScaleBiLog();
mpFisherInformation->setColorCoding(tcs);
mpFisherInformation->setColorScalingAutomatic(true);
mpFisherInformation->setArrayAnnotation(&mpProblem->getFisherInformation());
bool Enable = (mpProblem->getCrossValidationSet().getExperimentCount() > 0);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidations), Enable);
mpTabWidget->setTabEnabled(mpTabWidget->indexOf(mpCrossValidationValues), Enable);
// Loop over the cross validation
const CCrossValidationSet & CrossValidations = mpProblem->getCrossValidationSet();
imax = CrossValidations.getExperimentCount();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
mpCrossValidations->setRowCount(imax);
for (i = 0; i != imax; i++)
{
const CExperiment & Experiment = * CrossValidations.getExperiment(i);
pItem = new QTableWidgetItem(FROM_UTF8(Experiment.getObjectName()));
mpCrossValidations->setItem(i, 0, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getObjectiveValue()));
mpCrossValidations->setItem(i, 1, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getRMS()));
mpCrossValidations->setItem(i, 2, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getErrorMean()));
mpCrossValidations->setItem(i, 3, pItem);
pItem = new QTableWidgetItem(QString::number(Experiment.getErrorMeanSD()));
mpCrossValidations->setItem(i, 4, pItem);
}
mpCrossValidations->resizeColumnsToContents();
mpCrossValidations->resizeRowsToContents();
// Loop over the dependent objects
imax = CrossValidations.getDependentObjects().size();
if (mpProblem->getFunctionEvaluations() == 0)
imax = 0;
mpCrossValidationValues->setRowCount(imax);
for (i = 0; i != imax; i++)
{
const CCopasiObject * pObject = CrossValidations.getDependentObjects()[i];
if (pObject)
pItem = new QTableWidgetItem(FROM_UTF8(pObject->getObjectDisplayName()));
else
pItem = new QTableWidgetItem("Not Found");
mpCrossValidationValues->setItem(i, 0, pItem);
pItem = new QTableWidgetItem(QString::number(CrossValidations.getDependentObjectiveValues()[i]));
mpCrossValidationValues->setItem(i, 1, pItem);
pItem = new QTableWidgetItem(QString::number(CrossValidations.getDependentRMS()[i]));
mpCrossValidationValues->setItem(i, 2, pItem);
pItem = new QTableWidgetItem(QString::number(CrossValidations.getDependentErrorMean()[i]));
mpCrossValidationValues->setItem(i, 3, pItem);
pItem = new QTableWidgetItem(QString::number(CrossValidations.getDependentErrorMeanSD()[i]));
mpCrossValidationValues->setItem(i, 4, pItem);
}
mpCrossValidationValues->resizeColumnsToContents();
mpCrossValidationValues->resizeRowsToContents();
return true;
}
void ThreadRemoveExifDatas::run() {
QTableWidgetItem *item;
Exiv2::ExifData::iterator keyIteratorRemove;
Exiv2::ExifKey *keyRemove;
QVector<QString> listErrorRemoveFile;
QVector<int> listErrorRemoveFilePosition;
connect(this, SIGNAL(progressBarValue(int)), progressBar, SLOT(setValue(int)));
connect(this, SIGNAL(progressBarSetVisible(bool)), progressBar, SLOT(setVisible(bool)));
emit progressBarSetVisible(true);
progressBar->setRange(0, tableWidgetJpeg->rowCount());
for (int i = 0; i < tableWidgetJpeg->rowCount(); i++) {
try {
emit progressBarValue(i);
Exiv2::Image::AutoPtr image;
image = Exiv2::ImageFactory::open(tableWidgetJpeg->item(i, 7)->text().toStdString().c_str());
if (tableWidgetJpeg->item(i, 3) != 0 || tableWidgetJpeg->item(i, 4) != 0 || tableWidgetJpeg->item(i, 5) != 0) {
bool exifRemovido = false;
assert(image.get() != 0);
image->readMetadata();
Exiv2::ExifData &exifData = image->exifData();
Exiv2::ExifKey keyLatitude = Exiv2::ExifKey("Exif.GPSInfo.GPSLatitude");
keyIteratorRemove = exifData.findKey(keyLatitude);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSTimeStamp");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSDateStamp");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSVersionID");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSMapDatum");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSLatitudeRef");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSLongitude");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSLongitudeRef");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSAltitude");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSAltitudeRef");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSImgDirectionRef");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSImgDirection");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
keyRemove = new Exiv2::ExifKey("Exif.GPSInfo.GPSProcessingMethod");
keyIteratorRemove = exifData.findKey(*keyRemove);
if (keyIteratorRemove != exifData.end()) {
exifData.erase(keyIteratorRemove);
exifRemovido = true;
}
if (exifRemovido) {
QString softwareTag = QApplication::applicationName();
softwareTag += " ";
softwareTag += QApplication::applicationVersion();
exifData["Exif.Image.Software"] = softwareTag.toStdString();
}
image->setExifData(exifData);
image->writeMetadata();
QString itemStatus = QString::fromUtf8("Dados Removidos");
item = new QTableWidgetItem();
item->setText(itemStatus);
delete tableWidgetJpeg->takeItem(i, 3);
delete tableWidgetJpeg->takeItem(i, 4);
delete tableWidgetJpeg->takeItem(i, 5);
tableWidgetJpeg->setItem(i, 6, item);
} else {
QString itemStatus = QString::fromUtf8("Não Há Dados Para Remover");
item = new QTableWidgetItem();
item->setText(itemStatus);
tableWidgetJpeg->setItem(i, 6, item);
}
}
catch (Exiv2::AnyError& e) {
QString itemMsg;
switch (e.code()) {
case 2:
itemMsg = QString::fromUtf8("Erro ao Remover Arquivo");
// Quando ocorrer erro na remoção do arquivo, ele será colocado numa lista para
// que ao fim da execução seja tentado mais uma vez a sua remoção.
listErrorRemoveFile.push_back(tableWidgetJpeg->item(i, 7)->text());
listErrorRemoveFilePosition.push_back(i);
break;
case 9:
itemMsg = QString::fromUtf8("Erro de Acesso ao Arquivo");
break;
case 10:
itemMsg = QString::fromUtf8("Arquivo Somente Leitura");
break;
case 11:
itemMsg = QString::fromUtf8("Arquivo Inválido");
break;
}
item = new QTableWidgetItem();
item->setForeground(QColor(255, 0, 0));
item->setText(itemMsg);
tableWidgetJpeg->setItem(i, 6, item);
}
}
for (int i = 0; i < listErrorRemoveFile.size(); i++) {
//precisa pesquisar no disco se tem outro arquivo com o nome igual mas com a extensão diferente
// se achar, tem que remover o atual e renomear o outro arquivo.
QString fileName;
QString filePath;
QString itemMsg;
int pos;
pos = listErrorRemoveFile.at(i).lastIndexOf("/");
fileName.operator =(QString::fromUtf8(listErrorRemoveFile.at(i).right(listErrorRemoveFile.at(i).size() - pos - 1).toStdString().c_str()));
filePath = listErrorRemoveFile.at(i).left(pos);
QDir directory(filePath);
QStringList filesOnDirectory = directory.entryList(QDir::Files);
QString regularExpression(fileName);
regularExpression.append("[0-9]{1,4}");
QRegExp fileRegExp(regularExpression, Qt::CaseSensitive, QRegExp::RegExp);
QStringList filesLocated = filesOnDirectory.filter(fileRegExp);
for (int j = 0; j < filesLocated.size(); j++) {
itemMsg = QString::fromUtf8("Não Foi Possível Corrigir o Arquivo, Verifique Manualmente");
QFileInfo fileTemp(directory, filesLocated.at(j));
QFileInfo fileCurrent(directory, fileName);
if (fileTemp.size() > fileCurrent.size()) {
if (directory.remove(fileName)) {
if (directory.rename(filesLocated.at(j), fileName)) {
itemMsg = QString::fromUtf8("O Erro no Arquivo foi Corrigido");
delete tableWidgetJpeg->takeItem(listErrorRemoveFilePosition.at(i), 3);
delete tableWidgetJpeg->takeItem(listErrorRemoveFilePosition.at(i), 4);
delete tableWidgetJpeg->takeItem(listErrorRemoveFilePosition.at(i), 5);
}
}
} else {
if (directory.remove(filesLocated.at(j)))
itemMsg = QString::fromUtf8("O Erro no Arquivo foi Corrigido");
}
item = new QTableWidgetItem();
item->setForeground(QColor(0, 110, 0));
item->setText(itemMsg);
tableWidgetJpeg->setItem(listErrorRemoveFilePosition.at(i), 6, item);
}
}
emit progressBarValue(tableWidgetJpeg->rowCount());
sleep(1);
emit progressBarSetVisible(false);
}
void HdrWizard::updateTableGrid()
{
qDebug() << "HdrWizard::updateTableGrid(): Fill grid with values in the m_data structure";
int currentRow = m_ui->tableWidget->currentRow();
// empty grid...
m_ui->tableWidget->clear();
m_ui->tableWidget->setRowCount(0);
// insert the row at the bottom of the table widget
int counter = 0;
QStringList filesWithoutExif;
BOOST_FOREACH(const HdrCreationItem& item, *m_hdrCreationManager)
{
float normalizedEV = item.getEV() - m_hdrCreationManager->getEVOffset();
qDebug() << QString("HdrWizard::updateTableGrid(): Fill row %1: %2 %3 EV (%4 EV)")
.arg(counter)
.arg(item.filename())
.arg(item.getEV())
.arg(normalizedEV);
// fill graphical list
m_ui->tableWidget->insertRow(counter);
m_ui->tableWidget->setItem(counter, 0, new QTableWidgetItem(QFileInfo(item.filename()).fileName()));
if (item.hasEV())
{
QTableWidgetItem *tableitem = new QTableWidgetItem(buildEVString(normalizedEV));
tableitem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
m_ui->tableWidget->setItem(counter, 1, tableitem);
}
else
{
// if image doesn't contain (the required) exif tags
// I keep the name of all the files without exif data...
filesWithoutExif.push_back(item.filename());
QTableWidgetItem *tableitem = new QTableWidgetItem(QString(tr("Unknown")));
tableitem->setTextAlignment(Qt::AlignRight | Qt::AlignVCenter);
tableitem->setBackground(QBrush(Qt::yellow));
tableitem->setForeground(QBrush(Qt::red));
m_ui->tableWidget->setItem(counter, 1, tableitem);
}
++counter;
}
// highlight current row (possibly remain on the previously selected one!)
if (currentRow < 0)
{
if (m_hdrCreationManager->availableInputFiles() > 0)
{
currentRow = 0;
}
else
{
currentRow = -1;
}
}
else
{
if (currentRow > (int)m_hdrCreationManager->availableInputFiles())
{
currentRow = 0;
}
// else, don't change the value!
}
m_ui->tableWidget->selectRow(currentRow);
if (counter)
{
m_ui->clearListButton->setEnabled(true);
enableNextOrWarning(filesWithoutExif);
}
else
{
m_ui->clearListButton->setEnabled(false);
m_ui->removeImageButton->setEnabled(false);
m_ui->NextFinishButton->setEnabled(false);
m_ui->confirmloadlabel->setText(QString());
}
}
//Method to set dates in Calendar
void MonthView::SetDatesInCalendar(QDate dtStartDate, QDate dtEndDate, bool toFillData)
{
m_ptr_growth_animation_timer->stop();
int dayStartDate = dtStartDate.day();
int StartMonthDays = dtStartDate.daysInMonth();//Total days in selected month
int dayCurrMonth = 1;
int dayNextMonth = 1;
all_week_data = 0;
qreal week_total = 0;
int data = 0;
int sourceData = 0;
for(int row = 0; row < 6; row++)
{
week_total = 0; //add_Weekly_total = true;
for(int col = 0; col < 7; col++)
{
if ( m_vector_vector_view_selected_day_usage_values.size() != 42)
{
data = 0 ; sourceData =0;
} else
{
data = (qreal)((qreal)(50 * ( m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][0] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][1] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][2] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][3] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][4] ) ))/MaxUnit ; // qrand() % ((ui->tblDates->rowHeight(0) + 1) - 5) + 5;
sourceData = (qreal)((qreal)(50 * ( m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][source_name] )))/MaxUnit;// qrand() % (((data/2) + 1) - 2) + 2; // data % 2;
}
//Previous Month
if(dayStartDate <= StartMonthDays)
{
QTableWidgetItem *item = new QTableWidgetItem();
int day = dayStartDate++;
item->setData(0,
qVariantFromValue(StarRating(day,0,0, source_name,data,sourceData)));
if(dtStartDate.day() > 1)//When 3 months are displayed in Calendar, only then prev month date is grayed out
{
item->setData(0,
qVariantFromValue(StarRating(0,0,0, source_name,data,sourceData)));
data = 0;// Make it zero as not to be added with total
}
item->setTextAlignment(Qt::AlignTop | Qt::AlignRight);
QDate dt(dtStartDate.year(),dtStartDate.month(), locale->toInt(QString::number(day)));
QString str(dt.toString());
item->setWhatsThis(str);
if(dt.operator >(QDate::currentDate()))
{
data= 0;
if(dt.month() == QDate::currentDate().month() && dt.month() == StartDate.month()) //compare to current as well as calendar's month
{
item->setData(0,
qVariantFromValue(StarRating(-day,data,0, source_name,data,0)));
}
else
{
item->setData(0,
qVariantFromValue(StarRating(0,data,0, source_name,data,0)));
}
}
ui->tblDates->setItem(row,col,item);
}
else
{
QDate date = dtStartDate.addMonths(1);
int CurrentMonthDays = date.daysInMonth();
//Current month
if(dayCurrMonth <= CurrentMonthDays)
{
QTableWidgetItem *item = new QTableWidgetItem();
int day = dayCurrMonth++;
item->setData(0,
qVariantFromValue(StarRating(day,0,0, source_name,data,sourceData)));
if(dtStartDate.day() == 1)//When 2 months are displayed in Calendar, only then current month date is grayed out
{
item->setData(0,
qVariantFromValue(StarRating(0,0,0, source_name,data,sourceData)));
data = 0;// Make it zero as not to be added with total
}
item->setTextAlignment(Qt::AlignTop | Qt::AlignHCenter);
QDate dt(date.year(),date.month(), locale->toInt(QString::number(day)));
QString str(dt.toString());
item->setWhatsThis(str);
if(dt.operator >(QDate::currentDate()))
{
data= 0;
if(dt.month() == QDate::currentDate().month() && dt.month() == StartDate.month()) //compare to current as well as calendar's month
{
item->setData(0,
qVariantFromValue(StarRating(-day,data,0, source_name,data,0)));
}
else
{
item->setData(0,
qVariantFromValue(StarRating(0,data,0, source_name,data,0)));
}
}
ui->tblDates->setItem(row,col,item);
}
//Next month
else
{
if(dayNextMonth <= dtEndDate.day())
{
QTableWidgetItem *item = new QTableWidgetItem();
item->setForeground(QBrush(Qt::gray,Qt::SolidPattern));//Always grayed out
item->setData(0,
qVariantFromValue(StarRating(0,0,0, source_name,data,sourceData)));
data = 0;// Make it zero as not to be added with total
item->setTextAlignment(Qt::AlignTop | Qt::AlignHCenter);
int day = dayNextMonth++;
QDate dt(dtEndDate.year(),dtEndDate.month(), locale->toInt(QString::number(day)));
QString str(dt.toString());
item->setWhatsThis(str);
if(dt.operator >(QDate::currentDate()))
{
data= 0;
if(dt.month() == QDate::currentDate().month() && dt.month() == StartDate.month()) //compare to current as well as calendar's month
{
item->setData(0,
qVariantFromValue(StarRating(-day,data,0, source_name,data,0)));
}
else
{
item->setData(0,
qVariantFromValue(StarRating(0,data,0, source_name,data,0)));
}
}
ui->tblDates->setItem(row,col,item);
}
}
}
//For weekDays total
if(data > 0)
{
week_total += (m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][source_name]) ;
}
// week_total += m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][0] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][1] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][2] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][3] + m_vector_vector_view_selected_day_usage_values[(row * 7) + col ][4] ;//data;
}
all_week_data += week_total;
QTableWidgetItem *item = new QTableWidgetItem();
item->setData(0,
qVariantFromValue(StarRating(100,week_total,0, source_name,data,sourceData)));
item->setTextAlignment(Qt::AlignTop | Qt::AlignHCenter);
ui->tblDates->setItem(row,7,item);
}
if(toFillData)
{
m_ptr_growth_animation_timer->start();
}
}
